diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 96d02bd3..9afa1a47 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -22,6 +22,8 @@ jobs: - uses: leanprover/lean-action@v1 with: build-args: "--wfail -v" + - name: Check codegen'd IxVM kernel is up to date + run: lake exe ix codegen --check - name: Test Ix CLI run: lake test -- cli - name: Aiur tests diff --git a/Benchmarks/IxVM.lean b/Benchmarks/IxVM.lean index d38c2ed2..57f39187 100644 --- a/Benchmarks/IxVM.lean +++ b/Benchmarks/IxVM.lean @@ -34,7 +34,9 @@ def main : IO Unit := do let _ ← bgroup "IxVM benchmarks" { oneShot := true } do throughput (.Elements n.toUInt64 "consts") + -- IxVM-native prove: routes execution through the codegen'd Rust + -- kernel (`execute_generated`) instead of the bytecode interpreter. bench "serde/blake3 Nat.add_comm" - (aiurSystem.prove friParameters funIdx #[.ofNat n]) + (aiurSystem.proveIxVM friParameters funIdx #[.ofNat n]) ioBuffer return diff --git a/Benchmarks/Typecheck.lean b/Benchmarks/Typecheck.lean index 1906378b..047cbec7 100644 --- a/Benchmarks/Typecheck.lean +++ b/Benchmarks/Typecheck.lean @@ -172,11 +172,6 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do | .error e => IO.eprintln s!"deserialize {ixePath} failed: {e}"; return 1 | .ok env => pure env IO.println s!"Loaded {ixePath}: {ixonEnv.namedCount} named, {ixonEnv.constCount} consts" - -- Build the witness for `addr`: subject-only (`verify_const`) trusts deps; - -- otherwise the full-closure check (`verify_claim`, `check addr none`). - let mkWitness (addr : Address) : IO IxVM.ClaimHarness.ClaimWitness := - if subjectOnly then pure (IxVM.ClaimHarness.buildVerifyConst ixonEnv addr) - else IO.ofExcept (IxVM.ClaimHarness.buildClaimWitness ixonEnv (Ix.Claim.check addr none)) let mut targets : Array (String × Address) := #[] for arg in nameArgs do match Ix.Cli.NameResolve.resolveIxeAddr ixonEnv arg with @@ -186,16 +181,28 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do IO.eprintln "no requested constants were found in the env" return 1 + -- Build the env once into a Rust-owned `EnvHandle` and share it + -- across both Phase 1 and Phase 2 loops. Per-target FFI calls + -- reuse the parsed env — no per-call mmap / lazy-index rebuild. + let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 + | .ok h => pure h + -- Phase 1: execute every constant (cheap, deterministic structural metrics). - -- Carry each target's address through so phase 2 can rebuild its witness. + -- For full-closure check claims, use `checkAddrWithEnv` against the + -- shared `envHandle`. For `--subject-only` (`buildVerifyConst`), the + -- witness is a small subject-only blob — keep Lean witness + + -- `executeIxVM`. IO.println "── Phase 1: execute (witness generation) ──" let mut execed : Array (Result × Address) := #[] for (label, addr) in targets do try - let witness ← mkWitness addr let (res, execSec) ← timed fun _ => - Aiur.Bytecode.Toplevel.execute compiled.bytecode funIdx - witness.input witness.inputIOBuffer + if subjectOnly then + let witness := IxVM.ClaimHarness.buildVerifyConst ixonEnv addr + compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer + else + compiled.bytecode.checkAddrWithEnv funIdx envHandle addr.hash match res with | .error e => IO.eprintln s!" execute {label} failed: {e}" | .ok (_, _, queryCounts) => @@ -226,9 +233,25 @@ def runTypecheckCmd (p : Cli.Parsed) : IO UInt32 := do for i in [:ordered.size] do let (r, addr) := ordered[i]! try - let witness ← mkWitness addr - let (_, proveSec) ← timed fun _ => - aiurSystem.prove friParameters funIdx witness.input witness.inputIOBuffer + let (proveRes, proveSec) ← timed fun _ => + if subjectOnly then + let witness := IxVM.ClaimHarness.buildVerifyConst ixonEnv addr + let (claim, proof, ioBuf) := + aiurSystem.proveIxVM friParameters funIdx witness.input witness.inputIOBuffer + (.ok (claim, proof, ioBuf) : + Except String (Array Aiur.G × Aiur.Proof × Aiur.IOBuffer)) + else + match aiurSystem.proveAddrWithEnv friParameters funIdx envHandle addr.hash with + | .error e => .error e + | .ok (_claimBytes, proof, ioBuf) => + -- The shared envHandle path doesn't return an `Array G` + -- claim — adapt to the existing benchmark return shape + -- by recomputing the claim digest from the witness's + -- input (Phase 2 doesn't read it). + .ok (#[], proof, ioBuf) + match (proveRes : Except String (Array Aiur.G × Aiur.Proof × Aiur.IOBuffer)) with + | .error e => IO.eprintln s!" prove {r.name} failed: {e}"; continue + | .ok _ => pure () spent := spent + proveSec IO.println s!" {r.name}: prove={proveSec}s (cumulative {spent}s)" ordered := ordered.set! i ({ r with proveSec := some proveSec }, addr) diff --git a/Cargo.lock b/Cargo.lock index 13f6bf3b..bc102b9c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -81,6 +81,15 @@ version = "1.0.103" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "2a4385e2e34eb35d6b3efe798b9eb88096925d87726c0798709bf56d9ed84af3" +[[package]] +name = "ar_archive_writer" +version = "0.5.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4087686b4b0a3427190bae57a1d9a478dbb2d40c5dc1bd6e2b6d797913bdd348" +dependencies = [ + "object", +] + [[package]] name = "arrayref" version = "0.3.9" @@ -1731,6 +1740,21 @@ version = "1.0.18" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682" +[[package]] +name = "ix" +version = "0.1.0" +dependencies = [ + "aiur", + "dashmap", + "ix-common", + "ixon", + "multi-stark", + "num-bigint", + "rayon", + "rustc-hash", + "stacker", +] + [[package]] name = "ix-common" version = "0.1.0" @@ -1778,6 +1802,7 @@ dependencies = [ "iroh", "iroh-base", "itertools 0.14.0", + "ix", "ix-common", "ix-compile", "ix-kernel", @@ -2431,6 +2456,15 @@ dependencies = [ "objc2-security", ] +[[package]] +name = "object" +version = "0.37.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "ff76201f031d8863c38aa7f905eca4f53abbfa15f609db4277d44cd8938f33fe" +dependencies = [ + "memchr", +] + [[package]] name = "once_cell" version = "1.21.4" @@ -2958,6 +2992,16 @@ dependencies = [ "unicode-ident", ] +[[package]] +name = "psm" +version = "0.1.31" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "645dbe486e346d9b5de3ef16ede18c26e6c70ad97418f4874b8b1889d6e761ea" +dependencies = [ + "ar_archive_writer", + "cc", +] + [[package]] name = "quick-xml" version = "0.39.4" @@ -3254,7 +3298,7 @@ dependencies = [ "errno", "libc", "linux-raw-sys", - "windows-sys 0.52.0", + "windows-sys 0.61.2", ] [[package]] @@ -3557,6 +3601,19 @@ version = "1.2.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "6ce2be8dc25455e1f91df71bfa12ad37d7af1092ae736f3a6cd0e37bc7810596" +[[package]] +name = "stacker" +version = "0.1.24" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "640c8cdd92b6b12f5bcb1803ca3bbf5ab96e5e6b6b96b9ab77dabe9e880b3190" +dependencies = [ + "cc", + "cfg-if", + "libc", + "psm", + "windows-sys 0.61.2", +] + [[package]] name = "strength_reduce" version = "0.2.4" @@ -3640,7 +3697,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "230a1b821ccbd75b185820a1f1ff7b14d21da1e442e22c0863ea5f08771a8874" dependencies = [ "rustix", - "windows-sys 0.59.0", + "windows-sys 0.61.2", ] [[package]] diff --git a/Cargo.toml b/Cargo.toml index e3a2ae7f..b01f8ae2 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -4,6 +4,7 @@ members = [ "crates/common", "crates/compile", "crates/ffi", + "crates/ix", "crates/ixon", "crates/kernel", ] @@ -27,6 +28,7 @@ license = "MIT OR Apache-2.0" [workspace.dependencies] # Internal crates aiur = { path = "crates/aiur" } +ix = { path = "crates/ix" } ix-common = { path = "crates/common" } ix-compile = { path = "crates/compile" } ixon = { path = "crates/ixon" } diff --git a/Ix/Aiur/Protocol.lean b/Ix/Aiur/Protocol.lean index 7bfdd5df..b5d6b332 100644 --- a/Ix/Aiur/Protocol.lean +++ b/Ix/Aiur/Protocol.lean @@ -73,6 +73,66 @@ def prove (system : @& AiurSystem) (friParameters : @& FriParameters) let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ (claim, proof, ⟨ioData, ioMap⟩) +@[extern "rs_aiur_system_prove_ixvm"] +private opaque proveIxVM' : @& AiurSystem → @& FriParameters → + @& Bytecode.FunIdx → @& Array G → + (ioData : @& Array (G × Array G)) → + (ioMap : @& Array ((G × Array G) × IOKeyInfo)) → + Array G × Proof × Array (G × Array G) × Array ((G × Array G) × IOKeyInfo) + +/-- IxVM-native prove: same shape as `prove`, but routes execution + through the codegen'd Rust kernel (`execute_generated`) instead + of the bytecode interpreter. The resulting `Proof` is + verification-compatible with one from `prove`. Only valid when + `system.toplevel` is the IxVM kernel's bytecode. -/ +def proveIxVM (system : @& AiurSystem) (friParameters : @& FriParameters) + (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) : + Array G × Proof × IOBuffer := + let ioData := ioBuffer.data.toArray + let ioMap := ioBuffer.map.toArray + let (claim, proof, ioData, ioMap) := proveIxVM' system friParameters funIdx args + ioData ioMap + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + (claim, proof, ⟨ioData, ioMap⟩) + +@[extern "rs_aiur_system_prove_addr_with_env"] +private opaque proveAddrWithEnv' : @& AiurSystem → @& FriParameters → + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → + Except String (ByteArray × Proof × + Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) + +/-- Per-claim prove against a Rust-owned `EnvHandle`. Returns + `(claimBytes, proof, ioBuffer)` — Rust serializes the + reconstructed `Ix.Claim` via `ixon::Claim::put` so Lean can + deserialize directly without re-running the closure walk. -/ +def proveAddrWithEnv (system : @& AiurSystem) (friParameters : @& FriParameters) + (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (addrBytes : ByteArray) : + Except String (ByteArray × Proof × IOBuffer) := + match proveAddrWithEnv' system friParameters funIdx envHandle addrBytes with + | .error e => .error e + | .ok (claimBytes, proof, ioData, ioMap) => + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + .ok (claimBytes, proof, ⟨ioData, ioMap⟩) + +@[extern "rs_aiur_system_shard_prove_with_env"] +private opaque shardProveWithEnv' : @& AiurSystem → @& FriParameters → + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → + Except String (ByteArray × Proof × + Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) + +/-- Per-shard prove against a Rust-owned `EnvHandle`. -/ +def shardProveWithEnv (system : @& AiurSystem) (friParameters : @& FriParameters) + (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) (ownedBlob : ByteArray) : + Except String (ByteArray × Proof × IOBuffer) := + match shardProveWithEnv' system friParameters funIdx envHandle ownedBlob with + | .error e => .error e + | .ok (claimBytes, proof, ioData, ioMap) => + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + .ok (claimBytes, proof, ⟨ioData, ioMap⟩) + @[extern "rs_aiur_system_verify"] opaque verify : @& AiurSystem → @& FriParameters → @& Array G → @& Proof → Except String Unit diff --git a/Ix/Aiur/Semantics/BytecodeFfi.lean b/Ix/Aiur/Semantics/BytecodeFfi.lean index e3970d70..420be269 100644 --- a/Ix/Aiur/Semantics/BytecodeFfi.lean +++ b/Ix/Aiur/Semantics/BytecodeFfi.lean @@ -67,6 +67,37 @@ structure QueryCount where totalHits : Nat deriving Inhabited +-- =========================================================================== +-- EnvHandle: Rust-owned `ixon::Env` exposed to Lean as an opaque handle. +-- Built once per CLI invocation; reused across every per-claim and +-- per-shard FFI call so the env is parsed exactly once. +-- =========================================================================== + +private opaque EnvHandleNonempty : NonemptyType +def EnvHandle : Type := EnvHandleNonempty.type +instance : Nonempty EnvHandle := EnvHandleNonempty.property + +namespace EnvHandle + +@[extern "rs_aiur_env_handle_from_ixe"] +private opaque fromIxe' : @& ByteArray → Except String EnvHandle + +/-- Load an `EnvHandle` from a `.ixe` file path (UTF-8 ByteArray). + Rust mmap's the file zero-copy; the handle keeps the mapping + alive for as long as Lean retains it. -/ +def fromIxe (path : String) : Except String EnvHandle := + fromIxe' path.toUTF8 + +@[extern "rs_aiur_env_handle_from_bytes"] +private opaque fromBytes' : @& ByteArray → Except String EnvHandle + +/-- Build an `EnvHandle` from a serialized env blob (e.g. produced + by `Ixon.serEnv` on the compiled-Lean-env code path). -/ +def fromBytes (bytes : ByteArray) : Except String EnvHandle := + fromBytes' bytes + +end EnvHandle + namespace Bytecode.Toplevel @[extern "rs_aiur_toplevel_execute"] @@ -96,6 +127,88 @@ def execute (toplevel : @& Bytecode.Toplevel) let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } .ok (output, ⟨ioData, ioMap⟩, queryCounts) +@[extern "rs_aiur_toplevel_execute_ixvm"] +private opaque executeIxVM' : @& Bytecode.Toplevel → + @& Bytecode.FunIdx → @& Array G → + (ioData : @& Array (G × Array G)) → + (ioMap : @& Array ((G × Array G) × IOKeyInfo)) → + Except String (Array G × + (Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) × + Array (Nat × Nat)) + +/-- IxVM-native execution: same shape as `execute`, but routes the + function invocation through the codegen'd Rust kernel + (`crate::ix::aiur_ixvm::execute_generated`) instead of the + generic bytecode interpreter. The resulting `QueryRecord` is + byte-for-byte identical (modulo the standing codegen parity + invariant). Only valid when `toplevel` is the IxVM kernel's + `Bytecode.Toplevel` — other toplevels produce undefined results + because the generated function bodies are fixed at codegen time. -/ +def executeIxVM (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (args : @& Array G) (ioBuffer : IOBuffer) : + Except String (Array G × IOBuffer × Array QueryCount) := + let ioData := ioBuffer.data.toArray + let ioMap := ioBuffer.map.toArray + match executeIxVM' toplevel funIdx args ioData ioMap with + | .error e => .error e + | .ok (output, (ioData, ioMap), queryCounts) => + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } + .ok (output, ⟨ioData, ioMap⟩, queryCounts) + +-- (EnvHandle opaque type + constructors live above `namespace +-- Bytecode.Toplevel`; see `Aiur.EnvHandle`. The with-env FFI +-- declarations below reference `EnvHandle` and `Bytecode.Toplevel` +-- from the same scope.) + +@[extern "rs_aiur_toplevel_check_addr_with_env"] +private opaque checkAddrWithEnv' : @& Bytecode.Toplevel → + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → + Except String (Array G × + (Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) × + Array (Nat × Nat)) + +@[extern "rs_aiur_toplevel_shard_check_with_env"] +private opaque shardCheckWithEnv' : @& Bytecode.Toplevel → + @& Bytecode.FunIdx → @& EnvHandle → @& ByteArray → Bool → + Except String (Array G × + (Array (G × Array G) × Array ((G × Array G) × IOKeyInfo)) × + Array (Nat × Nat)) + + +/-- Per-claim check against a Rust-owned `EnvHandle`. `useBytecode` + selects the generic Aiur bytecode interpreter + (`Bytecode.Toplevel.execute`) over the codegen'd IxVM kernel + (`execute_ixvm`); useful for tight iteration loops on Lean-side + IxVM source where regenerating `crates/ix/src/aiur_ixvm.rs` and + recompiling Rust is too slow. -/ +def checkAddrWithEnv (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) + (addrBytes : ByteArray) (useBytecode : Bool := false) + : Except String (Array G × IOBuffer × Array QueryCount) := + match checkAddrWithEnv' toplevel funIdx envHandle addrBytes useBytecode with + | .error e => .error e + | .ok (output, (ioData, ioMap), queryCounts) => + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } + .ok (output, ⟨ioData, ioMap⟩, queryCounts) + +/-- Per-shard check against a Rust-owned `EnvHandle`. See + `checkAddrWithEnv` for `useBytecode` semantics. -/ +def shardCheckWithEnv (toplevel : @& Bytecode.Toplevel) + (funIdx : @& Bytecode.FunIdx) (envHandle : @& EnvHandle) + (ownedBlob : ByteArray) (useBytecode : Bool := false) + : Except String (Array G × IOBuffer × Array QueryCount) := + match shardCheckWithEnv' toplevel funIdx envHandle ownedBlob useBytecode with + | .error e => .error e + | .ok (output, (ioData, ioMap), queryCounts) => + let ioData := ioData.foldl (fun acc (k, v) => acc.insert k v) ∅ + let ioMap := ioMap.foldl (fun acc (k, v) => acc.insert k v) ∅ + let queryCounts := queryCounts.map fun (uniqueRows, totalHits) => { uniqueRows, totalHits } + .ok (output, ⟨ioData, ioMap⟩, queryCounts) + end Bytecode.Toplevel end Aiur diff --git a/Ix/Aiur/Stages/Codegen.lean b/Ix/Aiur/Stages/Codegen.lean new file mode 100644 index 00000000..f8564036 --- /dev/null +++ b/Ix/Aiur/Stages/Codegen.lean @@ -0,0 +1,991 @@ +/- + Aiur bytecode → Rust source codegen. + + Next stage after `Bytecode`. Walks a `Bytecode.Toplevel` and emits one + Rust fn per Aiur function: + + ```rust + fn aiur_fn_N( + inp: [G; INPUT_SIZE], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, + ) -> [G; OUTPUT_SIZE] + ``` + + `INPUT_SIZE = Function.layout.inputSize`. `OUTPUT_SIZE` derived from + the function's `Ctrl.return` arms (Aiur fn layouts are fixed; all + Returns within a fn agree). + + Architecture: build a structured Rust IR (`RustExpr` / `RustStmt` / + `RustItem`) by walking the Bytecode, then format the IR to a single + Rust source `String` at the end. No string interpolation during + codegen — collect IR, dispatch to string late. + + # Correctness invariant + + Generated code MUST produce a `QueryRecord` indistinguishable from + `crates/aiur/src/execute.rs`'s interpreter: + + - `function_queries[idx].insert(args, output, mult)` MUST happen on + `Ctrl::Return` of the callee, AFTER the callee's body's inserts. + - Cache-hit `multiplicity += G::ONE` MUST trigger iff + `!unconstrained && !op_unconstrained` for `Op::Call`, and + `!unconstrained` for `Op::Store` / `Op::Load`. + - `memory_queries[size]` insertion order: each unique store gets a + pointer = `memory_queries.len()` at that moment. + - `bytes1_queries` / `bytes2_queries` updates from `U8*` ops in + constrained mode, suppressed when `unconstrained == true`. + - `io_buffer` ops preserve order. + + # `unconstrained` propagation + + `unconstrained: bool` is the fn-local flag. Once `true`, stays `true`. + Each `Op::Call(callee, args, _, op_unconstrained)` invokes the callee + with `unconstrained || op_unconstrained`. + + # Status + + Skeleton: Rust IR + formatter. A few Op variants (`Const`, `Add` / + `Sub` / `Mul`, `EqZero`) emit faithful IR. `Ctrl::Return` + `Ctrl::Match` + emit faithful IR. + + Remaining (mechanical fill-in following the same IR shape): + - `Op::Call` cache-check via `ifLetSome` (needs IR extension) + - `Op::Store` / `Op::Load` / `Op::AssertEq` + - IO ops: `IOGetInfo`, `IOSetInfo`, `IORead`, `IOWrite` + - Byte ops: all `U8*` + `U32LessThan` (gated on `unconstrained`) + - `UnconstrainedBigUintDivMod`, `Debug` + - `Ctrl::MatchContinue` + `Ctrl::Yield` (needs `BlockResult` enum) + + Parity test BEFORE wiring into the build: generate code for one small + Aiur fn, run both backends on the same input, diff the resulting + `QueryRecord` byte-for-byte. Diverging records ⇒ invalid witnesses + ⇒ proving fails hard. +-/ +module +public import Ix.Aiur.Stages.Bytecode + +public section + +namespace Aiur.Codegen + +open Bytecode + +/-! ## Rust IR -/ + +mutual + +inductive RustExpr where + /-- A bare identifier (e.g. `record`, `__args`). -/ + | var (name : String) + /-- A literal emitted verbatim (numbers, strings, `true`, `false`). -/ + | lit (text : String) + /-- Path: `G::ZERO`, `ExecError::MatchNoCase`, etc. -/ + | path (segments : Array String) + /-- Function or method call: `callee(args)`. -/ + | call (callee : RustExpr) (args : Array RustExpr) + /-- Indexed access: `arr[idx]`. -/ + | index (arr : RustExpr) (idx : RustExpr) + /-- Field access: `e.field`. -/ + | field (e : RustExpr) (name : String) + /-- Binary operator: `a op b`. The formatter parenthesises. -/ + | binop (op : String) (a b : RustExpr) + /-- `*e`. -/ + | deref (e : RustExpr) + /-- `&e`. -/ + | ref (e : RustExpr) + /-- `vec![...]`, `[...]`, etc. — `macro!(args)`. -/ + | macroCall (name : String) (args : Array RustExpr) + /-- A Rust array literal: `[a, b, c]`. -/ + | arrayLit (elems : Array RustExpr) + /-- A labeled block expression: `'label: { stmts }`. Used by + MatchContinue: case bodies `break 'label vec![...]` to bubble + yielded values, the labeled block as a whole evaluates to the + yielded `Vec`. -/ + | labeledBlock (label : String) (stmts : Array RustStmt) + deriving Inhabited + +inductive RustStmt where + /-- `let [mut] name [: ty] = expr;` -/ + | letStmt (isMut : Bool) (name : String) (ty : Option String) (val : RustExpr) + /-- `*target += val;` (used for multiplicity bumps). -/ + | addAssign (target : RustExpr) (val : RustExpr) + /-- `expr;` -/ + | exprStmt (e : RustExpr) + /-- `return expr;` -/ + | returnStmt (e : RustExpr) + /-- `if cond { thenStmts } else { elseStmts? }` -/ + | ifStmt (cond : RustExpr) (thenStmts : Array RustStmt) (elseStmts : Option (Array RustStmt)) + /-- `if let Some(binding) = scrut { thenStmts } else { elseStmts }` — + the shape used for Aiur's memoization cache checks. -/ + | ifLetSome (binding : String) (scrut : RustExpr) + (thenStmts : Array RustStmt) (elseStmts : Array RustStmt) + /-- `match scrut { pats... }` -/ + | matchStmt (scrut : RustExpr) (arms : Array MatchArm) + /-- A nested block `{ stmts }` for scoping. -/ + | block (stmts : Array RustStmt) + /-- `break 'label expr;` — yield a value out of an enclosing + labeledBlock. -/ + | breakWith (label : String) (e : RustExpr) + deriving Inhabited + +inductive MatchPat where + | litU64 (n : Nat) + | wildcard + deriving Inhabited + +structure MatchArm where + pat : MatchPat + body : Array RustStmt + deriving Inhabited + +end + +/-- A generated top-level item. -/ +inductive RustItem where + /-- A constant: `const NAME: usize = value;` -/ + | constUsize (name : String) (value : Nat) + /-- A function. -/ + | function (name : String) (params : Array (String × String)) + (returnTy : String) (body : Array RustStmt) + /-- Raw text (prelude, enum decls, etc.). -/ + | raw (text : String) + deriving Inhabited + +/-! ## Pretty printer + + Indentation: 2 spaces per nesting level. Expressions render on one + line; statements get their own line. Match arms are one block each. +-/ + +@[inline] def indent (n : Nat) : String := + String.ofList (List.replicate (n * 2) ' ') + +def MatchPat.toStr : MatchPat → String + | .litU64 n => s!"{n}u64" + | .wildcard => "_" + +mutual + +partial def RustExpr.toStr : RustExpr → String + | .var n => n + | .lit t => t + | .path segs => "::".intercalate segs.toList + | .call c args => + let argList := ", ".intercalate (args.toList.map RustExpr.toStr) + s!"{c.toStr}({argList})" + | .index a i => s!"{a.toStr}[{i.toStr}]" + | .field e n => s!"{e.toStr}.{n}" + | .binop op a b => s!"({a.toStr} {op} {b.toStr})" + | .deref e => s!"*{e.toStr}" + | .ref e => s!"&{e.toStr}" + | .macroCall n args => + let argList := ", ".intercalate (args.toList.map RustExpr.toStr) + s!"{n}!({argList})" + | .arrayLit elems => + let lb := "[" + let rb := "]" + let elemList := ", ".intercalate (elems.toList.map RustExpr.toStr) + s!"{lb}{elemList}{rb}" + | .labeledBlock label stmts => + -- One-line approximation. Aiur case bodies are short enough. + let body := stmts.toList.map (RustStmt.toStr 0) |>.foldl (· ++ ·) "" + let lbrace := "{" + let rbrace := "}" + s!"'{label}: {lbrace} {body} {rbrace}" + +partial def RustStmt.toStr (d : Nat) : RustStmt → String + | .letStmt isMut name ty val => + let mutStr := if isMut then "mut " else "" + let tyStr := match ty with | some t => s!": {t}" | none => "" + s!"{indent d}let {mutStr}{name}{tyStr} = {val.toStr};\n" + | .addAssign target val => + s!"{indent d}{target.toStr} += {val.toStr};\n" + | .exprStmt e => s!"{indent d}{e.toStr};\n" + | .returnStmt e => s!"{indent d}return {e.toStr};\n" + | .ifLetSome binding scrut thenStmts elseStmts => Id.run do + let lbrace := "{" + let rbrace := "}" + let mut o := s!"{indent d}if let Some({binding}) = {scrut.toStr} {lbrace}\n" + o := o ++ stmtsToStr (d+1) thenStmts + o := o ++ s!"{indent d}{rbrace} else {lbrace}\n" + o := o ++ stmtsToStr (d+1) elseStmts + o := o ++ s!"{indent d}{rbrace}\n" + return o + | .ifStmt cond thenStmts elseStmts? => Id.run do + let lbrace := "{" + let rbrace := "}" + let mut o := s!"{indent d}if {cond.toStr} {lbrace}\n" + o := o ++ stmtsToStr (d+1) thenStmts + match elseStmts? with + | some elseStmts => + o := o ++ s!"{indent d}{rbrace} else {lbrace}\n" + o := o ++ stmtsToStr (d+1) elseStmts + o := o ++ s!"{indent d}{rbrace}\n" + | none => + o := o ++ s!"{indent d}{rbrace}\n" + return o + | .matchStmt scrut arms => Id.run do + let lbrace := "{" + let rbrace := "}" + let mut o := s!"{indent d}match {scrut.toStr} {lbrace}\n" + for arm in arms do + o := o ++ s!"{indent (d+1)}{arm.pat.toStr} => {lbrace}\n" + o := o ++ stmtsToStr (d+2) arm.body + o := o ++ s!"{indent (d+1)}{rbrace},\n" + o := o ++ s!"{indent d}{rbrace}\n" + return o + | .block stmts => Id.run do + let lbrace := "{" + let rbrace := "}" + let mut o := s!"{indent d}{lbrace}\n" + o := o ++ stmtsToStr (d+1) stmts + o := o ++ s!"{indent d}{rbrace}\n" + return o + | .breakWith label e => + s!"{indent d}break '{label} {e.toStr};\n" + +partial def stmtsToStr (d : Nat) (stmts : Array RustStmt) : String := Id.run do + let mut o := "" + for s in stmts do + o := o ++ s.toStr d + o + +end + +def RustItem.toStr : RustItem → String + | .constUsize n v => s!"const {n}: usize = {v};\n" + | .raw text => text + | .function name params returnTy body => Id.run do + let lbrace := "{" + let rbrace := "}" + let paramList := ",\n ".intercalate + (params.toList.map (fun (n, t) => s!"{n}: {t}")) + let mut o := s!"fn {name}(\n {paramList},\n) -> {returnTy} {lbrace}\n" + o := o ++ stmtsToStr 1 body + o := o ++ s!"{rbrace}\n\n" + return o + +/-! ## IR helper constructors -/ + +def gZero : RustExpr := .path #["G", "ZERO"] +def gOne : RustExpr := .path #["G", "ONE"] +def gFromU64 (n : Nat) : RustExpr := .call (.path #["G", "from_u64"]) #[.lit (toString n)] +def gFromBool (cond : RustExpr) : RustExpr := .call (.path #["G", "from_bool"]) #[cond] +def gFromUsize (n : RustExpr) : RustExpr := .call (.path #["G", "from_usize"]) #[n] + +/-- Local variable for Aiur ValIdx `i` — `__v_{i}`. Replaces the + interpreter's `map[i]` Vec lookup. -/ +def valVar (i : Nat) : RustExpr := .var s!"__v_{i}" + +/-- Emit a single-G let-binding for the next ValIdx slot. -/ +def declVal (idx : Nat) (rhs : RustExpr) : RustStmt := + .letStmt false s!"__v_{idx}" (some "G") rhs + +/-- The `[G; n]` array literal of `valVar` for `is`. -/ +def argsAsArray (is : Array ValIdx) : RustExpr := + .arrayLit (is.map valVar) + +/-- `record.function_queries[idx]` access. -/ +def funQueriesAt (idx : Nat) : RustExpr := + .index (.field (.var "record") "function_queries") (.lit (toString idx)) + +/-- `record.memory_queries.get_mut(&SIZE)?` chain — used by Store/Load. -/ +def memQueriesGetMut (size : Nat) : RustExpr := + .call (.field (.field (.var "record") "memory_queries") "get_mut") + #[.ref (.lit (toString size))] + +/-- `cond` Rust expression for `!unconstrained && !op_unconstrained` / + `!unconstrained` etc. We emit as `lit` to avoid building elaborate + AST for unary `!`. -/ +def litBool (b : Bool) : RustExpr := .lit (if b then "true" else "false") + +/-- `!unconstrained`. -/ +def notUnconstrained : RustExpr := .lit "!unconstrained" + +/-- `!unconstrained && !op_unconstrained` (or just `!unconstrained` when + `op_unconstrained == false`). -/ +def constrainedCond (opUn : Bool) : RustExpr := + if opUn then .lit "false" else notUnconstrained + +/-- `unconstrained || op_unconstrained` for callee propagation. -/ +def calleeUnconstrained (opUn : Bool) : RustExpr := + if opUn then .lit "true" else .var "unconstrained" + +/-! ## Op emission + + Each emitted Op mirrors `crates/aiur/src/execute.rs`'s matching arm. The + interpreter's `map: Vec` is gone: every Aiur ValIdx becomes a + real Rust local `__v_{i}: G`. Per-op output counts decide how many + new locals each op allocates; the counter is threaded via + `EmitM`. + + Multi-output ops emit consecutive let-bindings; helpers that need + a Vec-shaped scratch (byte ops via `bytes{1,2}_execute`) build a + small local Vec inside a sub-block and read outputs back out as + G values. +-/ + +/-- How many ValIdx slots an Op consumes (i.e. how much it grows + Aiur's value-stack). MUST match `execute.rs`'s `map.push` / + `map.extend` totals exactly per arm — else local-variable names + drift from the bytecode's expected ValIdx layout and subsequent + ops index the wrong values. -/ +def Op.outputCount : Op → Nat + | .const _ => 1 + | .add _ _ | .sub _ _ | .mul _ _ | .eqZero _ => 1 + | .call _ _ outSize _ => outSize + | .store _ => 1 + | .load size _ => size + | .assertEq _ _ => 0 + | .ioGetInfo _ _ => 2 + | .ioSetInfo _ _ _ _ => 0 + | .ioRead _ _ len => len + | .ioWrite _ _ => 0 + | .u8BitDecomposition _ => 8 + | .u8ShiftLeft _ | .u8ShiftRight _ => 1 + | .u8Xor _ _ | .u8And _ _ | .u8Or _ _ | .u8LessThan _ _ => 1 + | .u8Mul _ _ => 2 + | .u8Add _ _ | .u8Sub _ _ => 2 + | .u8ChainRotr7 _ _ | .u8ChainRotr4 _ _ => 3 + | .u32LessThan _ _ => 1 + | .u8RangeCheck _ _ => 0 + | .unconstrainedBigUintDivMod _ _ => 2 + | .debug _ _ => 0 + +private def emitConst (out : Nat) (c : Aiur.G) : Array RustStmt := + #[declVal out (gFromU64 c.n)] + +private def emitBinop (out : Nat) (op : String) (a b : ValIdx) : Array RustStmt := + #[declVal out (.binop op (valVar a) (valVar b))] + +private def emitEqZero (out : Nat) (a : ValIdx) : Array RustStmt := + #[declVal out (gFromBool (.binop "==" (valVar a) gZero))] + +/-- `Op::Call`: mirror execute.rs lines 284-305 (caller) + 625-633 + (callee's Return inserts into `function_queries[fun_idx]`). On + cache hit: bump multiplicity if both sides constrained, extend map + with cached output. On miss: direct Rust call to the generated + callee. -/ +private def emitCall (out : Nat) (callee : FunIdx) (args : Array ValIdx) + (outSize : Nat) (opUn : Bool) : Array RustStmt := Id.run do + -- Build the inner cache-check as a Rust block expression (raw lit). + -- Structured IR for if-let-as-expression would need a `blockExpr` + -- node; deferred until after parity testing validates the shape. + let argsStr : String := (argsAsArray args).toStr + -- Constant-fold the `unconstrained || OP_UN` / `!unconstrained && !OP_UN` + -- patterns based on the static `opUn` flag. When opUn = true the + -- callee always runs unconstrained AND the multiplicity bump is + -- always skipped; when opUn = false both expressions collapse to + -- just `unconstrained`. + let cuExpr : String := if opUn then "true" else "unconstrained" + let bumpCond : String := if opUn then "false" else "!unconstrained" + let bumpStmt : String := + if opUn then "" + else s!" if {bumpCond} \{ *result.multiplicity += G::ONE; }" + -- Skip `try_into().unwrap()` on the cache hit: we statically know + -- the cached output has exactly `OUT_{callee}` elements (only we + -- ever insert into this slot via the matching aiur_fn_{callee} + -- `Ctrl::Return`). An unchecked array copy is sound. + let retExpr : String := + s!" let __ret: [G; OUT_{callee}] = unsafe \{ *(result.output.as_ptr() as *const [G; OUT_{callee}]) }; __ret" + let blockExpr : String := + s!"\{ let __args: [G; IN_{callee}] = {argsStr};" ++ + s!" let __cu = {cuExpr};" ++ + s!" if let Some(result) = record.function_queries[{callee}].get_mut(&__args[..]) \{" ++ + bumpStmt ++ + retExpr ++ + s!" } else \{ aiur_fn_{callee}(__args, record, io_buffer, __cu)? } }" + let mut stmts : Array RustStmt := #[ + .letStmt false "__r_arr" (some s!"[G; OUT_{callee}]") (.lit blockExpr) + ] + for k in [0 : outSize] do + stmts := stmts.push (declVal (out + k) (.index (.var "__r_arr") (.lit (toString k)))) + return stmts + +/-- `Op::Store`: mirror execute.rs lines 306-326. Insert hit/miss into + `record.memory_queries[size]`; output is the allocated/cached ptr. -/ +private def emitStore (out : Nat) (values : Array ValIdx) : Array RustStmt := + let size := values.size + let valsStr : String := (argsAsArray values).toStr + let blockExpr : String := + s!"\{ let __values: [G; {size}] = {valsStr};" ++ + s!" let __mq = record.memory_queries.get_mut(&{size}).ok_or(ExecError::InvalidMemorySize({size}))?;" ++ + s!" if let Some(result) = __mq.get_mut(&__values[..]) \{" ++ + s!" if !unconstrained \{ *result.multiplicity += G::ONE; }" ++ + s!" result.output[0]" ++ + s!" } else \{" ++ + s!" let __ptr = G::from_usize(__mq.len());" ++ + s!" __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }" + #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] + +/-- `Op::Load`: mirror execute.rs lines 328-345. Look up by pointer + index, bump multiplicity if constrained, splat `size` outputs. -/ +private def emitLoad (out : Nat) (size : Nat) (ptr : ValIdx) : Array RustStmt := Id.run do + let blockExpr : String := + s!"\{ let __mq = record.memory_queries.get_mut(&{size}).ok_or(ExecError::InvalidMemorySize({size}))?;" ++ + s!" let __ptr_u64 = __v_{ptr}.as_canonical_u64();" ++ + s!" let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?;" ++ + s!" let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer \{ ptr: __ptr_u64, size: {size} })?;" ++ + s!" if !unconstrained \{ *__mult += G::ONE; }" ++ + s!" let __arr: [G; {size}] = __args[..{size}].try_into().unwrap(); __arr }" + let mut stmts : Array RustStmt := #[ + .letStmt false "__loaded" (some s!"[G; {size}]") (.lit blockExpr) + ] + for k in [0 : size] do + stmts := stmts.push (declVal (out + k) (.index (.var "__loaded") (.lit (toString k)))) + return stmts + +/-- `Op::AssertEq`: mirror execute.rs lines 346-363. -/ +private def emitAssertEq (xs ys : Array ValIdx) : Array RustStmt := + if xs.size != ys.size then + #[.exprStmt (.lit s!"return Err(ExecError::AssertEqLengthMismatch \{ lhs: {xs.size}, rhs: {ys.size} })")] + else Id.run do + let mut stmts : Array RustStmt := #[] + for (x, y) in xs.zip ys do + stmts := stmts.push (.ifStmt + (.binop "!=" (valVar x) (valVar y)) + #[.exprStmt (.lit s!"return Err(ExecError::AssertEqMismatch \{ lhs: __v_{x}.as_canonical_u64(), rhs: __v_{y}.as_canonical_u64() })")] + none) + return stmts + +/-! ### IO ops -/ + +/-- `Op::IOGetInfo`: pushes 2 outputs (idx, len). -/ +private def emitIOGetInfo (out : Nat) (channel : ValIdx) (key : Array ValIdx) : + Array RustStmt := + let keyStr := (argsAsArray key).toStr + let blockIdxLen : String := + s!"\{ let __key: [G; {key.size}] = {keyStr};" ++ + s!" let __info = io_buffer.get_info(__v_{channel}, &__key[..])?;" ++ + s!" (G::from_usize(__info.idx), G::from_usize(__info.len)) }" + #[ + .letStmt false "__io_pair" (some "(G, G)") (.lit blockIdxLen), + declVal out (.field (.var "__io_pair") "0"), + declVal (out + 1) (.field (.var "__io_pair") "1") + ] + +/-- `Op::IOSetInfo`: 0 outputs; side-effects io_buffer. -/ +private def emitIOSetInfo (channel : ValIdx) (key : Array ValIdx) + (idx len : ValIdx) : Array RustStmt := + let keyStr := (argsAsArray key).toStr + let stmt : String := + s!"\{ let __key: [G; {key.size}] = {keyStr};" ++ + s!" let __idx = usize::try_from(__v_{idx}.as_canonical_u64()).ok().ok_or(ExecError::IndexTooLarge(__v_{idx}.as_canonical_u64()))?;" ++ + s!" let __len = usize::try_from(__v_{len}.as_canonical_u64()).ok().ok_or(ExecError::IndexTooLarge(__v_{len}.as_canonical_u64()))?;" ++ + s!" io_buffer.set_info(__v_{channel}, __key.to_vec(), __idx, __len)?; }" + #[.exprStmt (.lit stmt)] + +/-- `Op::IORead`: pushes `len` outputs (one G per byte). -/ +private def emitIORead (out : Nat) (channel : ValIdx) (idx : ValIdx) (len : Nat) : + Array RustStmt := Id.run do + let blockExpr : String := + s!"\{ let __idx_u64 = __v_{idx}.as_canonical_u64();" ++ + s!" let __idx = usize::try_from(__idx_u64).ok().ok_or(ExecError::IndexTooLarge(__idx_u64))?;" ++ + s!" let __data = io_buffer.read(__v_{channel}, __idx, {len})?;" ++ + s!" let __arr: [G; {len}] = __data[..{len}].try_into().unwrap(); __arr }" + let mut stmts : Array RustStmt := #[ + .letStmt false "__io_read" (some s!"[G; {len}]") (.lit blockExpr) + ] + for k in [0 : len] do + stmts := stmts.push (declVal (out + k) (.index (.var "__io_read") (.lit (toString k)))) + return stmts + +/-- `Op::IOWrite`: 0 outputs; side-effects io_buffer. -/ +private def emitIOWrite (channel : ValIdx) (data : Array ValIdx) : Array RustStmt := + let dataIter : RustExpr := + .call (.field (.arrayLit (data.map valVar)) "into_iter") #[] + #[.exprStmt + (.call (.field (.var "io_buffer") "write") + #[valVar channel, dataIter])] + +/-! ### Byte ops + + All `U8*` ops are gated on `unconstrained`: in constrained mode + they go through `bytes{1,2}_execute` helpers (which update + `record.bytes{1,2}_queries`); in unconstrained mode they take a + pure arithmetic shortcut and skip the byte-chip queries. + + For codegen simplicity, the constrained path is emitted as a raw + helper call; the unconstrained shortcut is the pure variant of + the same op. The execute.rs interpreter does the same dispatch. +-/ + +/-- Bytes1 op. No scratch Vec — the constrained branch calls + `bytes1_*_value` (defined in `aiur::execute`) which + bumps the byte-chip queries and returns the gadget output by + value; the unconstrained branch calls the pure `Bytes1::*` + helper directly. -/ +private def emitU8Bytes1 (out : Nat) (valueHelper : String) + (unconShortcut : String) (byte : ValIdx) (outCount : Nat) : + Array RustStmt := Id.run do + if outCount == 1 then + let blockExpr : String := + s!"if unconstrained \{ {unconShortcut}(&__v_{byte}) }" ++ + s!" else \{ {valueHelper}(__v_{byte}, record) }" + return #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] + else + -- BitDecomposition returns [G; 8]; the unconstrained shortcut + -- is the pure `Bytes1::bit_decompose` which returns Vec. + -- Coerce its result into [G; outCount] for unified handling. + let blockExpr : String := + s!"if unconstrained \{ let __v: Vec = {unconShortcut}(&__v_{byte}); let __a: [G; {outCount}] = __v.try_into().unwrap(); __a }" ++ + s!" else \{ {valueHelper}(__v_{byte}, record) }" + let mut stmts : Array RustStmt := #[ + .letStmt false "__b1_out" (some s!"[G; {outCount}]") (.lit blockExpr) + ] + for k in [0 : outCount] do + stmts := stmts.push (declVal (out + k) (.index (.var "__b1_out") (.lit (toString k)))) + return stmts + +/-- Bytes2 op. Same pattern as `emitU8Bytes1` — no scratch Vec. -/ +private def emitU8Bytes2 (out : Nat) (valueHelper : String) + (unconShortcut : String) (i j : ValIdx) (outCount : Nat) : + Array RustStmt := Id.run do + if outCount == 1 then + let blockExpr : String := + s!"if unconstrained \{ Bytes2::{unconShortcut}(&__v_{i}, &__v_{j}) }" ++ + s!" else \{ {valueHelper}(__v_{i}, __v_{j}, record) }" + return #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] + else + -- 2-tuple outputs (Mul) or 3-tuple (ChainRotr7/4). + let blockExpr : String := + s!"if unconstrained \{ Bytes2::{unconShortcut}(&__v_{i}, &__v_{j}) }" ++ + s!" else \{ {valueHelper}(__v_{i}, __v_{j}, record) }" + let tupTy : String := + "(" ++ (String.intercalate ", " (List.replicate outCount "G")) ++ ")" + let mut stmts : Array RustStmt := #[ + .letStmt false "__b2_out" (some tupTy) (.lit blockExpr) + ] + for k in [0 : outCount] do + stmts := stmts.push (declVal (out + k) (.field (.var "__b2_out") (toString k))) + return stmts + +/-- `Op::U8Add`: gadget bumps `bytes2_queries.add` and returns + `(low, carry)`. Codegen now calls `bytes2_add_value` ONCE in + the constrained branch (vs the interpreter's two `Bytes2::add` + calls). -/ +private def emitU8Add (out : Nat) (i j : ValIdx) : Array RustStmt := + let blockExpr : String := + s!"if unconstrained \{ Bytes2::add(&__v_{i}, &__v_{j}) }" ++ + s!" else \{ bytes2_add_value(__v_{i}, __v_{j}, record) }" + #[ + .letStmt false "__b2_add" (some "(G, G)") (.lit blockExpr), + declVal out (.field (.var "__b2_add") "0"), + declVal (out + 1) (.field (.var "__b2_add") "1") + ] + +/-- `Op::U8Sub`: symmetric to U8Add. -/ +private def emitU8Sub (out : Nat) (i j : ValIdx) : Array RustStmt := + let blockExpr : String := + s!"if unconstrained \{ Bytes2::sub(&__v_{i}, &__v_{j}) }" ++ + s!" else \{ bytes2_sub_value(__v_{i}, __v_{j}, record) }" + #[ + .letStmt false "__b2_sub" (some "(G, G)") (.lit blockExpr), + declVal out (.field (.var "__b2_sub") "0"), + declVal (out + 1) (.field (.var "__b2_sub") "1") + ] + +/-- `Op::U32LessThan`: mirror execute.rs lines 477-505. Pure + compare + 6-byte-pair range-check via + `bytes2_queries.bump_range_check` (constrained mode only). -/ +private def emitU32LessThan (out : Nat) (x y : ValIdx) : Array RustStmt := + let blockExpr : String := + s!"\{ let __a_val = __v_{x}.as_canonical_u64();" ++ + s!" let __b_val = __v_{y}.as_canonical_u64();" ++ + s!" let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?;" ++ + s!" let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?;" ++ + s!" let __result = G::from_bool(__a_u32 < __b_u32);" ++ + s!" if !unconstrained \{" ++ + s!" let __x_bytes = __a_u32.to_le_bytes();" ++ + s!" let __z_bytes = __b_u32.to_le_bytes();" ++ + s!" let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1);" ++ + s!" let __y_bytes = __c_u32.to_le_bytes();" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1]));" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3]));" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1]));" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3]));" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1]));" ++ + s!" record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3]));" ++ + s!" } __result }" + #[.letStmt false s!"__v_{out}" (some "G") (.lit blockExpr)] + +/-- `Op::U8RangeCheck`: 0 outputs; pure range-check side effect. -/ +private def emitU8RangeCheck (i j : ValIdx) : Array RustStmt := + let stmt : String := + s!"if !unconstrained \{" ++ + s!" let __vi = __v_{i}; let __vj = __v_{j};" ++ + s!" let __bi = __vi.as_canonical_u64(); let __bj = __vj.as_canonical_u64();" ++ + s!" if __bi >= 256 \{ return Err(ExecError::U8RangeCheckFailed(__bi)); }" ++ + s!" if __bj >= 256 \{ return Err(ExecError::U8RangeCheckFailed(__bj)); }" ++ + s!" record.bytes2_queries.bump_range_check(&__vi, &__vj);" ++ + s!" }" + #[.exprStmt (.lit stmt)] + +/-- `Op::UnconstrainedBigUintDivMod`: BigUint hint, 2 outputs + (q_ptr, r_ptr). Calls the extracted `unconstrained_big_uint_div_mod_helper` + which returns `(G, G)` directly. -/ +private def emitUncBigUintDivMod (out : Nat) (a b : ValIdx) : Array RustStmt := + let blockExpr : String := + s!"unconstrained_big_uint_div_mod_helper(__v_{a}, __v_{b}, record)?" + #[ + .letStmt false "__bu_qr" (some "(G, G)") (.lit blockExpr), + declVal out (.field (.var "__bu_qr") "0"), + declVal (out + 1) (.field (.var "__bu_qr") "1") + ] + +/-- `Op::Debug`: 0 outputs; println side effect. Skipped for now. -/ +private def emitDebug : Array RustStmt := #[] + +/-- Top-level op dispatch. `out` = the first ValIdx for outputs; + callers must advance their counter by `Op.outputCount`. -/ +def emitOp (out : Nat) (op : Op) : Array RustStmt := + match op with + | .const c => emitConst out c + | .add a b => emitBinop out "+" a b + | .sub a b => emitBinop out "-" a b + | .mul a b => emitBinop out "*" a b + | .eqZero a => emitEqZero out a + | .call callee args outSz opUn => emitCall out callee args outSz opUn + | .store vs => emitStore out vs + | .load size ptr => emitLoad out size ptr + | .assertEq xs ys => emitAssertEq xs ys + | .ioGetInfo ch key => emitIOGetInfo out ch key + | .ioSetInfo ch key idx len => emitIOSetInfo ch key idx len + | .ioRead ch idx len => emitIORead out ch idx len + | .ioWrite ch data => emitIOWrite ch data + | .u8BitDecomposition b => emitU8Bytes1 out "bytes1_bit_decompose_value" "Bytes1::bit_decompose" b 8 + | .u8ShiftLeft b => emitU8Bytes1 out "bytes1_shift_left_value" "Bytes1::shift_left" b 1 + | .u8ShiftRight b => emitU8Bytes1 out "bytes1_shift_right_value" "Bytes1::shift_right" b 1 + | .u8Xor i j => emitU8Bytes2 out "bytes2_xor_value" "xor" i j 1 + | .u8Mul i j => emitU8Bytes2 out "bytes2_mul_value" "mul" i j 2 + | .u8And i j => emitU8Bytes2 out "bytes2_and_value" "and" i j 1 + | .u8Or i j => emitU8Bytes2 out "bytes2_or_value" "or" i j 1 + | .u8LessThan i j => emitU8Bytes2 out "bytes2_less_than_value" "less_than" i j 1 + | .u8ChainRotr7 i j => emitU8Bytes2 out "bytes2_chain_rotr7_value" "chain_rotr7" i j 3 + | .u8ChainRotr4 i j => emitU8Bytes2 out "bytes2_chain_rotr4_value" "chain_rotr4" i j 3 + | .u8Add i j => emitU8Add out i j + | .u8Sub i j => emitU8Sub out i j + | .u32LessThan a b => emitU32LessThan out a b + | .u8RangeCheck i j => emitU8RangeCheck i j + | .unconstrainedBigUintDivMod a b => emitUncBigUintDivMod out a b + | .debug _ _ => emitDebug + +/-! ## Ctrl emission -/ + +/-- Scan a Block for the first `Ctrl.return`'s arity. Aiur fn layouts + are fixed, so all Returns in a fn agree; we only need one. -/ +partial def findReturnArity (b : Block) : Option Nat := + ctrlArity b.ctrl +where + ctrlArity : Ctrl → Option Nat + | .return _ vals => some vals.size + | .yield _ _ => none + | .match _ cases dflt? => + let viaCases := cases.findSome? (fun ⟨_, blk⟩ => findReturnArity blk) + match viaCases with + | some n => some n + | none => dflt?.bind findReturnArity + | .matchContinue _ cases dflt? _ _ _ cont => + let viaCases := cases.findSome? (fun ⟨_, blk⟩ => findReturnArity blk) + let viaDflt := dflt?.bind findReturnArity + let viaCont := findReturnArity cont + viaCases <|> viaDflt <|> viaCont + +/-- Codegen state: `nextVal` is the next ValIdx slot to allocate for + op outputs (must match Aiur's value-stack growth exactly); + `nextLabel` is a fresh counter for unique `'__mc_N` labels in + nested `MatchContinue`s. -/ +structure EmitState where + nextVal : Nat + nextLabel : Nat + deriving Inhabited + +abbrev EmitM (α : Type) := StateM EmitState α + +@[inline] def freshLabel : EmitM String := do + let s ← get + set { s with nextLabel := s.nextLabel + 1 } + return s!"__mc_{s.nextLabel}" + +/-- Allocate `count` consecutive ValIdx slots and return the base. -/ +@[inline] def allocVals (count : Nat) : EmitM Nat := do + let s ← get + set { s with nextVal := s.nextVal + count } + return s.nextVal + +/-- Run `m` with the current `nextVal` snapshotted; on exit restore + `nextVal` to its value at entry. Used for `Match` / `MatchContinue` + case bodies, which logically execute from the SAME value-stack + snapshot that existed before the match dispatch. -/ +@[inline] def withSavedNextVal (m : EmitM α) : EmitM α := do + let saved := (← get).nextVal + let a ← m + modify ({ · with nextVal := saved }) + return a + +mutual + +/-- Emit a Block's stmts. `mcLabel?` is the label of the enclosing + `MatchContinue` (used by `Ctrl.yield` to `break` with values). + A Block whose Ctrl is `Return` does NOT bubble — it always emits + the outer fn's `return`. -/ +partial def emitBlock (funIdx : FunIdx) (mcLabel? : Option String) + (b : Block) : EmitM (Array RustStmt) := do + let mut stmts : Array RustStmt := #[] + for op in b.ops do + let outBase ← allocVals (Op.outputCount op) + stmts := stmts ++ emitOp outBase op + let ctrlStmts ← emitCtrl funIdx mcLabel? b.ctrl + return stmts ++ ctrlStmts + +partial def emitCtrl (funIdx : FunIdx) (mcLabel? : Option String) + (ctrl : Ctrl) : EmitM (Array RustStmt) := do + match ctrl with + | .return _ outs => + -- Mirror execute.rs Ctrl::Return: build the output array, insert + -- into function_queries (binding to the per-fn `inp` slice for + -- args), then Rust-return the array. Ignores `mcLabel?` because + -- Return exits the whole fn. + let outArr : RustStmt := + .letStmt false "__ret" (some s!"[G; OUT_{funIdx}]") + (.arrayLit (outs.map valVar)) + let insertCall : RustStmt := + .exprStmt (.call + (.field + (.index (.field (.var "record") "function_queries") + (.lit (toString funIdx))) + "insert") + #[.ref (.index (.var "inp") (.lit "..")), + .ref (.index (.var "__ret") (.lit "..")), + gFromBool (.lit "!unconstrained")]) + -- Wrap in Ok(...) since fn now returns Result<[G; OUT_N], ExecError>. + return #[outArr, insertCall, + .returnStmt (.call (.var "Ok") #[.var "__ret"])] + | .match valIdx cases dflt? => do + -- Each arm body executes from the SAME value-stack snapshot as + -- match entry. Snapshot nextVal per arm so per-arm allocations + -- don't leak to siblings. + let mut arms : Array MatchArm := #[] + for ⟨key, blk⟩ in cases do + let armBody ← withSavedNextVal (emitBlock funIdx mcLabel? blk) + arms := arms.push { pat := .litU64 key.n, body := armBody } + let dfltBody ← (match dflt? with + | some d => withSavedNextVal (emitBlock funIdx mcLabel? d) + | none => pure #[ + .returnStmt + (.call (.var "Err") + #[.call (.path #["ExecError", "MatchNoCase"]) + #[.call (.field (valVar valIdx) "as_canonical_u64") #[]]])]) + arms := arms.push { pat := .wildcard, body := dfltBody } + return #[.matchStmt + (.call (.field (valVar valIdx) "as_canonical_u64") #[]) + arms] + | .matchContinue valIdx cases dflt? outputSize _shAux _shLk continuation => do + -- Snapshot the value-stack base for the case bodies; they all + -- run from this same snapshot. + -- + -- Generated shape (no `map`, only locals): + -- let __mc_out_N: [G; OUT_SIZE] = '__mc_N: { + -- match __v_{valIdx}.as_canonical_u64() { + -- K1 => { ... break '__mc_N [__v_a, __v_b, ...]; }, + -- ... + -- _ => { ... }, + -- } + -- }; + -- let __v_{base}: G = __mc_out_N[0]; + -- let __v_{base+1}: G = __mc_out_N[1]; + -- ... // outputSize values rebound at outer scope + -- /* continuation emitted with nextVal = base + outputSize */ + let label ← freshLabel + let mut arms : Array MatchArm := #[] + for ⟨key, blk⟩ in cases do + let armBody ← withSavedNextVal (emitBlock funIdx (some label) blk) + arms := arms.push { pat := .litU64 key.n, body := armBody } + let dfltBody ← (match dflt? with + | some d => withSavedNextVal (emitBlock funIdx (some label) d) + | none => pure #[ + .returnStmt + (.call (.var "Err") + #[.call (.path #["ExecError", "MatchNoCase"]) + #[.call (.field (valVar valIdx) "as_canonical_u64") #[]]])]) + arms := arms.push { pat := .wildcard, body := dfltBody } + let matchStmt : RustStmt := + .matchStmt (.call (.field (valVar valIdx) "as_canonical_u64") #[]) arms + -- Reserve `outputSize` slots at outer scope for the yielded values. + let outBase ← allocVals outputSize + let yieldedLet : RustStmt := + .letStmt false s!"__mc_out_{label}" (some s!"[G; {outputSize}]") + (.labeledBlock label #[matchStmt]) + let mut splat : Array RustStmt := #[] + for k in [0 : outputSize] do + splat := splat.push + (declVal (outBase + k) + (.index (.var s!"__mc_out_{label}") (.lit (toString k)))) + let contStmts ← emitBlock funIdx mcLabel? continuation + return #[yieldedLet] ++ splat ++ contStmts + | .yield _ outs => + -- Yield: bubble values to the enclosing `MatchContinue`'s labeled + -- block via `break '__mc_N vec![...];`. Only valid inside a + -- MatchContinue case body, so `mcLabel?` MUST be set; if it isn't, + -- emit a panic so the failure is obvious during testing. + match mcLabel? with + | some label => + return #[.breakWith label (.arrayLit (outs.map valVar))] + | none => + return #[.exprStmt + (.lit "unreachable!(\"Ctrl::Yield outside of MatchContinue context\")")] + +end + +/-! ## Function & toplevel emission -/ + +def emitFunction (funIdx : FunIdx) (f : Function) : Array RustItem := Id.run do + let inSize := f.layout.inputSize + let outSize := (findReturnArity f.body).getD 0 + let inputSizeConst := RustItem.constUsize s!"INPUT_SIZE_{funIdx}" inSize + let inConst := RustItem.constUsize s!"IN_{funIdx}" inSize + let outConst := RustItem.constUsize s!"OUT_{funIdx}" outSize + -- Bind inputs as `__v_0..__v_{inSize-1}` so subsequent op outputs + -- can reference them by ValIdx. + let mut bindInputs : Array RustStmt := #[] + for i in [0 : inSize] do + bindInputs := bindInputs.push + (.letStmt false s!"__v_{i}" (some "G") (.index (.var "inp") (.lit (toString i)))) + -- nextVal starts at inSize (the next free ValIdx after the inputs). + let initState : EmitState := { nextVal := inSize, nextLabel := 0 } + let (bodyStmts, _) := (emitBlock funIdx none f.body).run initState + let body := bindInputs ++ bodyStmts + -- Wrap the whole body in `stacker::maybe_grow` so deep Aiur + -- recursion grows the stack on demand instead of overflowing. + -- Red zone 64KB / new stack 4MB — when the current thread has + -- <64KB of stack left, stacker allocates a fresh 4MB segment + -- and runs the closure there. Repeats as deep as the recursion + -- goes. + let lbrace := "{" + let rbrace := "}" + let bodyText : String := stmtsToStr 2 body + let fnText : String := + s!"fn aiur_fn_{funIdx}(\n" ++ + s!" inp: [G; IN_{funIdx}],\n" ++ + s!" record: &mut QueryRecord,\n" ++ + s!" io_buffer: &mut IOBuffer,\n" ++ + s!" unconstrained: bool,\n" ++ + s!") -> Result<[G; OUT_{funIdx}], ExecError> {lbrace}\n" ++ + s!" stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || {lbrace}\n" ++ + bodyText ++ + s!" {rbrace})\n" ++ + s!"{rbrace}\n\n" + #[inputSizeConst, inConst, outConst, .raw fnText] + +/-- Header that's always emitted (file comments, lint allows, and the + fixed `use` items every generated body references). Per-op + helpers (`bytes2_xor_value`, etc.) are added only when the body + actually mentions them — see `emitConditionalImports`. -/ +def emitPreludeHeader : String := + "// Auto-generated by Aiur codegen. Do not edit.\n\ + //\n\ + // Mirrors `crates/aiur/src/execute.rs`'s QueryRecord side effects exactly.\n\ + //\n\ + // Skip rustfmt — this file is huge and the codegen lays it out\n\ + // for the compiler, not for humans.\n\ + #![cfg_attr(rustfmt, rustfmt::skip)]\n\ + #![allow(\n\ + \x20\x20unused_variables, unused_assignments, unused_mut, dead_code,\n\ + \x20\x20unused_parens, non_snake_case, clippy::all,\n\ + )]\n\ + \n\ + use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64};\n\ + use aiur::G;\n" + +/-- The set of optional `aiur::execute` items the codegen + might emit references to. Each pair is `(rust_path, search_token)` + — if `search_token` appears anywhere in the body string, the item + is included in the generated `use` block. The token is the exact + identifier that appears at every call site; substring match is + safe because all of these names are unique within the generated + file (no other crate-level item has the same identifier). -/ +def optionalExecuteUses : Array (String × String) := #[ + ("bytes1_bit_decompose_value", "bytes1_bit_decompose_value"), + ("bytes1_shift_left_value", "bytes1_shift_left_value"), + ("bytes1_shift_right_value", "bytes1_shift_right_value"), + ("bytes2_xor_value", "bytes2_xor_value"), + ("bytes2_and_value", "bytes2_and_value"), + ("bytes2_or_value", "bytes2_or_value"), + ("bytes2_less_than_value", "bytes2_less_than_value"), + ("bytes2_mul_value", "bytes2_mul_value"), + ("bytes2_add_value", "bytes2_add_value"), + ("bytes2_sub_value", "bytes2_sub_value"), + ("bytes2_chain_rotr7_value", "bytes2_chain_rotr7_value"), + ("bytes2_chain_rotr4_value", "bytes2_chain_rotr4_value"), + ("unconstrained_big_uint_div_mod_helper", "unconstrained_big_uint_div_mod_helper"), + ("CodegenBytes1 as Bytes1", "Bytes1::"), + ("CodegenBytes2 as Bytes2", "Bytes2::") +] + +/-- Build the `use aiur::execute::{...};` block, including only + items whose search token appears in `body`. -/ +def emitConditionalImports (body : String) : String := Id.run do + let always : Array String := #["ExecError", "IOBuffer", "QueryRecord"] + let mut items : Array String := always + for (path, token) in optionalExecuteUses do + if (body.splitOn token).length > 1 then + items := items.push path + let joined : String := items.toList.foldl + (fun acc s => if acc.isEmpty then s else acc ++ ", " ++ s) "" + s!"use aiur::execute::\{ {joined} };\n\n" + +/-- Build the dispatch entry point `pub fn execute_generated(...)` + that maps a `fun_idx` to the right `aiur_fn_N` invocation. Mirrors + the interpreter's `execute::execute` signature so callers (kernel + runner, tests) can swap it in. -/ +def emitDispatch (tl : Toplevel) : RustItem := Id.run do + let mut arms : Array MatchArm := #[] + for funIdx in [0 : tl.functions.size] do + let armBody : Array RustStmt := #[ + .letStmt false "__inp" (some s!"[G; IN_{funIdx}]") + (.lit "args.try_into().expect(\"input size mismatch\")"), + .letStmt false "__out" none + (.lit s!"aiur_fn_{funIdx}(__inp, record, io_buffer, false)?"), + .returnStmt (.call (.var "Ok") + #[.call (.field (.var "__out") "to_vec") #[]]) + ] + arms := arms.push { pat := .litU64 funIdx, body := armBody } + arms := arms.push { + pat := .wildcard, + body := #[.returnStmt + (.call (.var "Err") + #[.call (.path #["ExecError", "InvalidFunIdx"]) #[.var "fun_idx"]])] + } + -- Emit raw text for the dispatch fn so we can prefix `pub(crate)` + -- without extending RustItem. The body is built via stmtsToStr at + -- the right indentation. + let body : Array RustStmt := #[.matchStmt (.lit "fun_idx as u64") arms] + let lbrace := "{" + let rbrace := "}" + .raw (s!"pub(crate) fn execute_generated(\n" ++ + s!" fun_idx: usize,\n" ++ + s!" args: &[G],\n" ++ + s!" record: &mut QueryRecord,\n" ++ + s!" io_buffer: &mut IOBuffer,\n" ++ + s!") -> Result, ExecError> {lbrace}\n" ++ + stmtsToStr 1 body ++ + s!"{rbrace}\n") + +/-- Emit Rust source for the whole `Bytecode.Toplevel`. Builds the + body first, then emits a prelude whose `use` block lists only + the helpers the body actually mentions. -/ +def emit (tl : Toplevel) : String := Id.run do + let mut items : Array RustItem := #[] + for funIdx in [0 : tl.functions.size] do + items := items ++ emitFunction funIdx tl.functions[funIdx]! + items := items.push (emitDispatch tl) + let mut bodyStr := "" + for it in items do + bodyStr := bodyStr ++ it.toStr + emitPreludeHeader ++ emitConditionalImports bodyStr ++ bodyStr + +end Aiur.Codegen + +end diff --git a/Ix/Cli/CheckCmd.lean b/Ix/Cli/CheckCmd.lean index 5f55d2b5..067436a2 100644 --- a/Ix/Cli/CheckCmd.lean +++ b/Ix/Cli/CheckCmd.lean @@ -102,16 +102,56 @@ def emitStats (compiled : Aiur.CompiledToplevel) try Aiur.printStats stats finally let _ ← IO.setStdout old -/-- Run a single witness through the compiled Aiur bytecode. -/ +/-- What a single `runOne` invocation is targeting. + + * `addr`: full-closure `Claim.check addr none` — dispatch via + `checkAddrWithEnv` / `proveAddrWithEnv` (handle required). + * `shard`: `Claim.checkEnv root none` over `owned` blocks — + dispatch via `shardCheckWithEnv` / `shardProveWithEnv` + (handle required). + * `leanW`: a pre-built `ClaimWitness` — used by `--interp` + mode and by `--claim ` over a non-`check addr none` + persisted claim. No envHandle needed. + + The env lives once per CLI invocation in a Rust-owned + `Aiur.EnvHandle`. Lean threads a `@& EnvHandle` reference + through every per-target FFI call, eliminating per-call env + re-parse. -/ +inductive Target where + | addr (a : Address) + | shard (owned : Array Address) + | leanW (w : IxVM.ClaimHarness.ClaimWitness) + +/-- Run a single check claim through the codegen'd IxVM Rust kernel. + The `envHandle?` is `none` only for `.leanW` targets (`--interp` + fallback); the addr/shard arms require it. -/ def runCompiled (compiled : Aiur.CompiledToplevel) (printStats : Bool) - (statsOut : Option String) (witness : IxVM.ClaimHarness.ClaimWitness) - (label : String) : IO UInt32 := do + (statsOut : Option String) (useBytecode : Bool) + (envHandle? : Option Aiur.EnvHandle) + (target : Target) (label : String) : IO UInt32 := do IO.println s!"Typechecking {label}" (← IO.getStdout).flush - let funIdx := compiled.getFuncIdx witness.funcName |>.get! - match compiled.bytecode.execute funIdx witness.input witness.inputIOBuffer with + let funIdx := compiled.getFuncIdx `verify_claim |>.get! + let buildBlob (owned : Array Address) : ByteArray := Id.run do + let mut blob := ByteArray.empty + for x in owned do blob := blob ++ x.hash + pure blob + let res := + match target, envHandle? with + | .addr a, some envHandle => + compiled.bytecode.checkAddrWithEnv funIdx envHandle a.hash useBytecode + | .shard owned, some envHandle => + compiled.bytecode.shardCheckWithEnv funIdx envHandle (buildBlob owned) useBytecode + | .leanW witness, _ => + if useBytecode then + compiled.bytecode.execute funIdx witness.input witness.inputIOBuffer + else + compiled.bytecode.executeIxVM funIdx witness.input witness.inputIOBuffer + | _, none => + .error "internal: addr/shard target with no envHandle" + match res with | .error e => - IO.eprintln s!"{label}: Aiur execution error: {e}" + IO.eprintln s!"{label}: IxVM-native Aiur execution error: {e}" return 1 | .ok (_output, _ioBuffer, queryCounts) => if printStats then emitStats compiled queryCounts statsOut @@ -138,24 +178,41 @@ def runInterp (decls : Aiur.Source.Decls) /-- Shared driver for `ix check` / `ix prove`. Loads either a `.ixe` env (with optional `--claim` over a persisted claim, or per-name iteration) or the compiled-in Lean env (per-name iteration only), - constructs each `(Claim, Witness, label)` triple, and dispatches - to `runOne`. Accumulates failures + prints a `[logTag]` summary. + constructs each `(Claim, WitnessSource, label)` triple, and + dispatches to `runOne`. Accumulates failures + prints a `[logTag]` + summary. `runOne` ignores `Claim` for `ix check` (the witness encodes the claim digest in its IO buffer); `ix prove` uses it to persist - the claim alongside the proof wrapper. -/ + the claim alongside the proof wrapper. + + The `WitnessSource` is `Native` (Rust-built witness from a + `.ixe` path + target addr) whenever both are available and the + claim is the common `Claim.check addr none` shape — avoids the + per-byte boxing into `Aiur.G` that dominates wall time on heavy + claims. Falls back to `Lean` when the env is the compiled-in + Lean env (no `.ixe` to mmap) or when the persisted `--claim` + variant isn't `check addr none`. -/ def forEachClaim (ixePath : Option String) (claimHex : Option String) (names : List String) - (keepGoing : Bool) (logTag : String) - (runOne : Ix.Claim → IxVM.ClaimHarness.ClaimWitness → String → IO UInt32) + (keepGoing : Bool) (logTag : String) (forceLeanWitness : Bool) + (runOne : Ix.Claim → Option Aiur.EnvHandle → Target → String → IO UInt32) : IO UInt32 := do let mut failures : Array String := #[] match ixePath with | some path => + -- Build the env once for the entire batch. The lazy index parse + -- runs O(num_consts) once at handle construction; all per-name + -- FFI calls below share the parsed env (no per-call re-mmap). + let envHandle ← match Aiur.EnvHandle.fromIxe path with + | .error e => + IO.eprintln s!"EnvHandle.fromIxe {path}: {e}"; return 1 + | .ok h => pure h + -- We still load a Lean-side Ixon.Env for `resolveIxeAddr` (the + -- name → address resolution used by `--claim` / per-name modes) + -- and for the rare non-`check addr none` claim-variant Lean + -- witness builder. Anon load is lazy zero-copy. let bytes ← IO.FS.readBinFile path - -- Anon load: lazy zero-copy constants, binder metadata dropped. The Aiur - -- check circuit consumes only anonymous constants, blobs, and per-Defn - -- reducibility hints — mirrors the Rust kernel's `get_anon_mmap`. let ixonEnv ← match Ixon.deEnvAnon bytes with | .error e => IO.eprintln s!"Failed to deserialize {path}: {e}"; return 1 @@ -164,10 +221,18 @@ def forEachClaim {ixonEnv.constCount} consts, {ixonEnv.blobCount} blobs" if let some hex := claimHex then let (claim, trees) ← loadClaimAndTrees hex - let witness ← IO.ofExcept <| - IxVM.ClaimHarness.buildClaimWitness ixonEnv claim trees let label := s!"claim {hex}" - if (← runOne claim witness label) ≠ 0 then + -- Persisted `--claim` may be any `Claim` variant; only the + -- `check addr none` shape has a Rust-witness fast path today. + -- Other variants (eval/reveal/contains/checkEnv-with-asm) + -- still build the witness in Lean. + let target : Target ← match claim with + | .check addr none => pure (.addr addr) + | _ => + let witness ← IO.ofExcept <| + IxVM.ClaimHarness.buildClaimWitness ixonEnv claim trees + pure (.leanW witness) + if (← runOne claim (some envHandle) target label) ≠ 0 then failures := failures.push label else if names.isEmpty then let sorted := ixonEnv.named.toArray.qsort @@ -176,8 +241,12 @@ def forEachClaim let leanName := ixNameToLeanName ixName let label := toString leanName let claim := Ix.Claim.check named.addr none - let witness ← mkWitness named.addr ixonEnv - if (← runOne claim witness label) ≠ 0 then + let target : Target ← + if forceLeanWitness then + let w ← mkWitness named.addr ixonEnv + pure (.leanW w) + else pure (.addr named.addr) + if (← runOne claim (some envHandle) target label) ≠ 0 then failures := failures.push label if !keepGoing then break else @@ -190,28 +259,43 @@ def forEachClaim | some addr => let label := arg let claim := Ix.Claim.check addr none - let witness ← mkWitness addr ixonEnv - if (← runOne claim witness label) ≠ 0 then + let target : Target ← + if forceLeanWitness then + let w ← mkWitness addr ixonEnv + pure (.leanW w) + else pure (.addr addr) + if (← runOne claim (some envHandle) target label) ≠ 0 then failures := failures.push label if !keepGoing then break | none => if claimHex.isSome then IO.eprintln "error: --claim requires --ixe "; return 1 let env ← get_env! - let buildOne (name : Lean.Name) : - IO (Ix.Claim × IxVM.ClaimHarness.ClaimWitness) := do + -- Compiled-Lean-env path. Builds a per-name Ixon env in Lean + -- memory, serializes to a byte blob, and constructs an + -- `EnvHandle` from it. Each name has its own closure-rooted + -- env, so the handle is rebuilt per name. (The `--ixe` arm + -- can share one handle across many names; this arm cannot + -- without a shared-env preprocess pass.) + let runOneByName (name : Lean.Name) (label : String) : IO UInt32 := do let ixonEnv ← IxVM.ClaimHarness.loadIxonEnv name env let addr ← IxVM.ClaimHarness.lookupAddr ixonEnv name let claim := Ix.Claim.check addr none - let witness ← mkWitness addr ixonEnv - pure (claim, witness) + if forceLeanWitness then + let w ← mkWitness addr ixonEnv + runOne claim none (.leanW w) label + else + let envBytes := Ixon.serEnv ixonEnv + let envHandle ← match Aiur.EnvHandle.fromBytes envBytes with + | .error e => throw (IO.userError s!"EnvHandle.fromBytes failed for {label}: {e}") + | .ok h => pure h + runOne claim (some envHandle) (.addr addr) label if names.isEmpty then let sorted := env.constants.toList.toArray.qsort (fun a b => toString a.1 < toString b.1) for (name, _) in sorted do let label := toString name - let (claim, witness) ← buildOne name - if (← runOne claim witness label) ≠ 0 then + if (← runOneByName name label) ≠ 0 then failures := failures.push label if !keepGoing then break else @@ -224,8 +308,7 @@ def forEachClaim else continue | some name => let label := toString name - let (claim, witness) ← buildOne name - if (← runOne claim witness label) ≠ 0 then + if (← runOneByName name label) ≠ 0 then failures := failures.push label if !keepGoing then break @@ -338,6 +421,31 @@ def runShardOwned (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) | .error e => IO.eprintln s!"shard witness build failed: {e}"; return 1 | .ok (claim, witness) => runOne claim witness s!"shard {shardK}" +/-- IxVM-native fast path: dispatch through `shardCheckWithEnv` (a + Rust-owned `EnvHandle` reused across calls). Caller threads in + the pre-built envHandle so all shards in an all-shards run share + one env parse. -/ +def runShardOwnedNative (envHandle : Aiur.EnvHandle) (compiled : Aiur.CompiledToplevel) + (printStats : Bool) (statsOut : Option String) (useBytecode : Bool) + (ixonEnv : Ixon.Env) (blocks : Array Address) (shardK : Nat) : IO UInt32 := do + let owned := ownedConstsForBlocks ixonEnv blocks + IO.println s!"[shard] shard {shardK}: {blocks.size} owned blocks → \ + {owned.size}/{ixonEnv.consts.size} owned consts" + let label := s!"shard {shardK}" + IO.println s!"Typechecking {label}" + (← IO.getStdout).flush + let funIdx := compiled.getFuncIdx `verify_claim |>.get! + let mut blob := ByteArray.empty + for a in owned do + blob := blob ++ a.hash + match compiled.bytecode.shardCheckWithEnv funIdx envHandle blob useBytecode with + | .error e => + IO.eprintln s!"{label}: IxVM-native shard check error: {e}" + return 1 + | .ok (_output, _ioBuffer, queryCounts) => + if printStats then emitStats compiled queryCounts statsOut + pure 0 + /-- Manifest-driven check/prove of one shard `shardK` of the partition. -/ def runShardCheckManifest (manifestPath ixePath : String) (shardK : Nat) (runOne : Ix.Claim → IxVM.ClaimHarness.ClaimWitness → String → IO UInt32) : IO UInt32 := do @@ -347,6 +455,46 @@ def runShardCheckManifest (manifestPath ixePath : String) (shardK : Nat) | none => IO.eprintln s!"shard {shardK} out of range ({shards.size} shards)"; return 1 | some blocks => runShardOwned ixonEnv blocks shardK runOne +/-- IxVM-native shard check, single shard. Builds an `EnvHandle` + once for this one call. -/ +def runShardCheckManifestNative (manifestPath ixePath : String) (shardK : Nat) + (compiled : Aiur.CompiledToplevel) (printStats : Bool) + (statsOut : Option String) (useBytecode : Bool) : IO UInt32 := do + match (← loadEnvAndShards manifestPath ixePath) with + | .error e => IO.eprintln e; return 1 + | .ok (ixonEnv, shards) => match shards[shardK]? with + | none => IO.eprintln s!"shard {shardK} out of range ({shards.size} shards)"; return 1 + | some blocks => + let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 + | .ok h => pure h + runShardOwnedNative envHandle compiled printStats statsOut useBytecode ixonEnv blocks shardK + +/-- IxVM-native check over EVERY shard. Builds the `EnvHandle` ONCE + and shares it across every shard's FFI call (no per-shard + re-mmap). Caller-side: skips the coverage check; trust the user + (or run a separate `--ixes`-only coverage probe first). -/ +def runShardManifestAllNative (manifestPath ixePath : String) (jobs? : Option Nat) + (compiled : Aiur.CompiledToplevel) (printStats : Bool) + (statsOut : Option String) (useBytecode : Bool) : IO UInt32 := do + match (← loadEnvAndShards manifestPath ixePath) with + | .error e => IO.eprintln e; return 1 + | .ok (ixonEnv, shards) => + let envHandle ← match Aiur.EnvHandle.fromIxe ixePath with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixePath}: {e}"; return 1 + | .ok h => pure h + let maxJobs := max 1 (jobs?.getD shards.size) + let mut rc : UInt32 := 0 + for chunk in (shards.mapIdx (fun k b => (b, k))).toList.toChunks maxJobs do + let tasks ← chunk.mapM fun (blocks, k) => + IO.asTask (prio := .dedicated) + (runShardOwnedNative envHandle compiled printStats statsOut useBytecode ixonEnv blocks k) + for t in tasks do + match t.get with + | .ok r => if r != 0 then rc := 1 + | .error e => IO.eprintln s!"shard check task failed: {e}"; rc := 1 + pure rc + /-- Run the shard operation over EVERY shard — the whole-partition behavior of `--ixes` with no `--shard` (used by `prove`). Loads the env once. Returns 1 if any shard fails, else 0. -/ @@ -425,7 +573,14 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do -- Always silence the Rust-side `[compile_env]` progress logs. The -- per-name labels + stats are signal enough at this layer. Std.Internal.UV.System.osSetenv "IX_QUIET" "1" - let interp := p.hasFlag "interp" + let interpMode : Option String := (p.flag? "interp").map (·.as! String) + let interpSource := interpMode == some "source" + let useBytecode := interpMode == some "bytecode" + match interpMode with + | none | some "source" | some "bytecode" => pure () + | some other => + IO.eprintln s!"error: --interp expects \"source\" or \"bytecode\", got \"{other}\"" + return 1 let keepGoing := p.hasFlag "keep-going" let statsOut : Option String := (p.flag? "stats-out").map (·.as! String) @@ -442,26 +597,58 @@ def runCheckCmd (p : Cli.Parsed) : IO UInt32 := do let toplevel ← match IxVM.ixVM with | .error e => IO.eprintln s!"Toplevel merging failed: {e}"; return 1 | .ok t => pure t - let runOne : IxVM.ClaimHarness.ClaimWitness → String → IO UInt32 ← - if interp then do + -- `runOne` consumes `(claim, envHandle?, target, label)`. For the + -- codegen path it dispatches via `runCompiled`. For `--interp` + -- it builds a `ClaimWitness` from the target — `.leanW` is + -- already a witness; `.addr` would require running the Rust + -- witness builder Lean-side, which `--interp` is meant to + -- bypass. So `--interp` rejects `.addr`/`.shard` targets here; + -- the legacy `runShardCheckManifest` path is used for `--interp` + -- shard mode. + let runOne : Ix.Claim → Option Aiur.EnvHandle → Target → String → IO UInt32 ← + if interpSource then do let decls ← match toplevel.mkDecls with | .error e => IO.eprintln s!"mkDecls failed: {e}"; return 1 | .ok d => pure d - pure (runInterp decls) + let go (_ : Ix.Claim) (_ : Option Aiur.EnvHandle) (target : Target) + (label : String) : IO UInt32 := + match target with + | .leanW w => runInterp decls w label + | _ => do + IO.eprintln s!"{label}: --interp requires a Lean witness; \ + addr/shard targets unreachable here" + pure 1 + pure go else do let compiled ← match toplevel.compile with | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 | .ok c => pure c - pure (runCompiled compiled printStats statsOut) + let go (_ : Ix.Claim) (envHandle? : Option Aiur.EnvHandle) (target : Target) + (label : String) : IO UInt32 := + runCompiled compiled printStats statsOut useBytecode envHandle? target label + pure go match ixePath, ixesPath, shardK with | some ixe, some manifest, some k => - return (← runShardCheckManifest manifest ixe k (fun _c w l => runOne w l)) + if interpSource then + return (← runShardCheckManifest manifest ixe k + (fun c w l => runOne c none (.leanW w) l)) + else do + let compiled ← match toplevel.compile with + | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 + | .ok c => pure c + return (← runShardCheckManifestNative manifest ixe k compiled printStats statsOut useBytecode) | some ixe, some manifest, none => - return (← runShardCheckAll manifest ixe ((p.flag? "jobs").map (·.as! Nat)) - (fun _c w l => runOne w l)) + if interpSource then + return (← runShardCheckAll manifest ixe ((p.flag? "jobs").map (·.as! Nat)) + (fun c w l => runOne c none (.leanW w) l)) + else do + let compiled ← match toplevel.compile with + | .error e => IO.eprintln s!"Compilation failed: {e}"; return 1 + | .ok c => pure c + return (← runShardManifestAllNative manifest ixe + ((p.flag? "jobs").map (·.as! Nat)) compiled printStats statsOut useBytecode) | _, _, _ => - forEachClaim ixePath claimHex names keepGoing "check" - (fun _ w l => runOne w l) + forEachClaim ixePath claimHex names keepGoing "check" interpSource runOne end Ix.Cli.CheckCmd @@ -471,7 +658,7 @@ def checkCmd : Cli.Cmd := `[Cli| "Typecheck Lean / `.ixe` constants through the IxVM Aiur kernel" FLAGS: - interp; "Use the Aiur interpreter (richer per-execution error diagnostics) instead of the compiled bytecode runner." + interp : String; "Use an interpreter instead of the codegen'd IxVM Rust kernel. Modes: `source` = Aiur source interpreter (richer per-execution error diagnostics, slowest); `bytecode` = generic Aiur bytecode interpreter (skips the regen + cargo rebuild cycle when iterating on `Ix/IxVM/*.lean`). Omit the flag entirely for the native codegen kernel." "keep-going"; "Continue past failures and report them at the end instead of halting on the first." "ixe" : String; "Path to a serialized `.ixe` env. When set, the binary reads the env from disk instead of using the compiled-in Lean env." "claim" : String; "32-byte hex address of a persisted `Ix.Claim` in `~/.ix/store/`. When set, runs the `verify_claim` entrypoint once over the claim's witness against the `--ixe` env (single execution, skips per-const iteration)." diff --git a/Ix/Cli/CodegenCmd.lean b/Ix/Cli/CodegenCmd.lean new file mode 100644 index 00000000..e2417122 --- /dev/null +++ b/Ix/Cli/CodegenCmd.lean @@ -0,0 +1,84 @@ +/- + `ix codegen`: write the IxVM kernel as a Rust source file via the + Bytecode → Rust codegen pass. + + Output path is fixed at compile time: `crates/ix/src/aiur_ixvm.rs`. + The generated file is the single destination; no flag overrides. + + Output: a Rust module body containing one `fn aiur_fn_N(...)` per + Aiur kernel function, plus per-fn `IN_N` / `OUT_N` / `INPUT_SIZE_N` + size constants and the dispatch entry `execute_generated`. + + Before integrating into the build pipeline: + 1. Generate code for a single small Aiur fn (e.g. `klimbs_add`). + 2. Drop the generated source into a Rust test crate. + 3. Run both backends (`execute_generated` vs the interpreter + `execute::execute`) on identical input. + 4. Diff the resulting `QueryRecord`. Any divergence ⇒ invalid + witnesses ⇒ proving fails hard. + + Only after parity is confirmed should this be wired into the main + ix build pipeline as a build-script step. +-/ +module +public import Cli +public import Ix.Aiur.Compiler +public import Ix.Aiur.Stages.Codegen +public import Ix.IxVM + +public section + +namespace Ix.Cli.CodegenCmd + +open Aiur + +/-- Fixed destination — compile-time constant, no CLI override. -/ +def codegenOutPath : String := "crates/ix/src/aiur_ixvm.rs" + +def runCodegenCmd (p : Cli.Parsed) : IO UInt32 := do + let checkOnly := p.hasFlag "check" + -- Compile the IxVM source to bytecode. + let src ← match IxVM.ixVM with + | .ok src => pure src + | .error e => IO.eprintln s!"IxVM source error: {repr e}"; return 1 + let compiled ← match src.compile with + | .ok c => pure c + | .error e => IO.eprintln s!"Aiur compile error: {e}"; return 1 + let rustSource := Aiur.Codegen.emit compiled.bytecode + if checkOnly then + -- CI mode: compare emitted source against the on-disk file. + -- Exit 0 if identical, 1 otherwise. Does not write. + let existing ← try + pure (some (← IO.FS.readFile codegenOutPath)) + catch _ => pure none + match existing with + | none => + IO.eprintln s!"[codegen --check] {codegenOutPath} missing" + return 1 + | some onDisk => + if onDisk == rustSource then + IO.println s!"[codegen --check] {codegenOutPath} up to date \ + ({rustSource.length} bytes, {compiled.bytecode.functions.size} aiur fns)" + return 0 + else + IO.eprintln s!"[codegen --check] {codegenOutPath} STALE: \ + on-disk {onDisk.length} bytes, would emit {rustSource.length} bytes. \ + Re-run `ix codegen` and commit the result." + return 1 + IO.FS.writeFile codegenOutPath rustSource + IO.println s!"[codegen] wrote {rustSource.length} bytes to {codegenOutPath} \ + ({compiled.bytecode.functions.size} aiur fns)" + return 0 + +end Ix.Cli.CodegenCmd + +open Ix.Cli.CodegenCmd in +def codegenCmd : Cli.Cmd := `[Cli| + "codegen" VIA runCodegenCmd; + "Compile the IxVM Aiur kernel to Rust source via the Bytecode → Rust codegen pass. Writes to `crates/ix/src/aiur_ixvm.rs` (fixed path, no override). PARITY UNVERIFIED — run the generated code on test fixtures against the interpreter before trusting any witness it produces." + + FLAGS: + "check"; "CI mode: compare the emitted source against the on-disk file at `crates/ix/src/aiur_ixvm.rs` and exit 0 if identical, 1 otherwise. Does not modify the file." +] + +end diff --git a/Ix/Cli/ProveCmd.lean b/Ix/Cli/ProveCmd.lean index 5b1fb25a..8f515882 100644 --- a/Ix/Cli/ProveCmd.lean +++ b/Ix/Cli/ProveCmd.lean @@ -58,29 +58,91 @@ private def friParameters : Aiur.FriParameters := { queryProofOfWorkBits := 0 } -/-- Run Aiur prove for one (claim, witness) pair, wrap into an - `Ixon.Proof`, persist claim + wrapper, and print the resulting - proof hex. Plugs into `Ix.Cli.CheckCmd.forEachClaim`. -/ def proveOne (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) (claim : Ix.Claim) - (witness : IxVM.ClaimHarness.ClaimWitness) + (envHandle? : Option Aiur.EnvHandle) + (target : Ix.Cli.CheckCmd.Target) (label : String) : IO UInt32 := do IO.println s!"Proving {label}" (← IO.getStdout).flush - let funIdx ← match compiled.getFuncIdx witness.funcName with + let funIdx ← match compiled.getFuncIdx `verify_claim with | some i => pure i | none => - IO.eprintln s!"{label}: entrypoint `{witness.funcName}` missing from compiled toplevel" + IO.eprintln s!"{label}: entrypoint `verify_claim` missing from compiled toplevel" return 1 let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) - let (_aiurClaim, proof, _outIO) := - aiurSystem.prove friParameters funIdx witness.input witness.inputIOBuffer + -- Native IxVM path: routes execution + STARK prove through the + -- codegen'd Rust kernel. `.addr` / `.shard` go through the + -- envHandle-based prove FFIs (witness + execute + prove all in + -- one Rust trip). `.leanW` consumes a pre-built `ClaimWitness` + -- via `proveIxVM` (used for non-`check addr none` `--claim hex`). + let proof : Aiur.Proof ← match target, envHandle? with + | .addr a, some envHandle => + match aiurSystem.proveAddrWithEnv friParameters funIdx envHandle a.hash with + | .error e => + IO.eprintln s!"{label}: proveAddrWithEnv error: {e}" + return 1 + | .ok (_claimBytes, proof, _outIO) => pure proof + | .shard owned, some envHandle => + let mut blob := ByteArray.empty + for x in owned do blob := blob ++ x.hash + match aiurSystem.shardProveWithEnv friParameters funIdx envHandle blob with + | .error e => + IO.eprintln s!"{label}: shardProveWithEnv error: {e}" + return 1 + | .ok (_claimBytes, proof, _outIO) => pure proof + | .leanW witness, _ => + let (_aiurClaim, proof, _outIO) := + aiurSystem.proveIxVM friParameters funIdx witness.input witness.inputIOBuffer + pure proof + | _, none => + IO.eprintln s!"{label}: internal: addr/shard target with no envHandle" + return 1 let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) IO.println (toString proofAddr) return 0 +/-- Per-shard prove via the end-to-end Rust path + (`shardProveIxVM`): witness build, `execute_ixvm`, and STARK + prove run in one FFI trip with the parallel Rust witness + builder. -/ +def runShardProveNative (manifestPath : String) (envHandle : Aiur.EnvHandle) + (ixonEnv : Ixon.Env) (shards : Array (Array Address)) (shardK : Nat) + (aiurSystem : Aiur.AiurSystem) (compiled : Aiur.CompiledToplevel) + (_printStats : Bool) : IO UInt32 := do + match shards[shardK]? with + | none => IO.eprintln s!"shard {shardK} out of range (0..{shards.size})"; return 1 + | some blocks => do + let owned := Ix.Cli.CheckCmd.ownedConstsForBlocks ixonEnv blocks + let mut blob := ByteArray.empty + for a in owned do + blob := blob ++ a.hash + let label := s!"shard {shardK}" + IO.println s!"Proving {label}" + (← IO.getStdout).flush + let funIdx := compiled.getFuncIdx `verify_claim |>.get! + match aiurSystem.shardProveWithEnv friParameters funIdx envHandle blob with + | .error e => + IO.eprintln s!"{label}: shardProveWithEnv error: {e}" + return 1 + | .ok (claimBytes, proof, _outIO) => + -- Rust returns the canonical CheckEnv claim's wire bytes; deserialize + -- back to `Ix.Claim` to persist alongside the proof. Avoids + -- recomputing the closure walk + canonical AssumptionTree Lean-side. + match Ixon.runGet Ix.Claim.get claimBytes with + | .error e => + IO.eprintln s!"{label}: Claim wire-decode failed: {e}" + return 1 + | .ok claim => do + let _ ← StoreIO.toIO (Store.write (Ix.Claim.ser claim)) + let wrapper : Ixon.Proof := { claim, proof := proof.toBytes } + let proofAddr ← StoreIO.toIO (Store.write (Ixon.Proof.ser wrapper)) + IO.println (toString proofAddr) + let _ := manifestPath -- kept for parity with previous signature + return 0 + def runProveCmd (p : Cli.Parsed) : IO UInt32 := do Std.Internal.UV.System.osSetenv "IX_QUIET" "1" let keepGoing := p.hasFlag "keep-going" @@ -97,11 +159,32 @@ def runProveCmd (p : Cli.Parsed) : IO UInt32 := do let runOne := proveOne aiurSystem compiled match ixePath, (p.flag? "ixes").map (·.as! String), (p.flag? "shard").map (·.as! Nat) with | some ixe, some manifest, some k => - Ix.Cli.CheckCmd.runShardCheckManifest manifest ixe k runOne + -- IxVM-native shard prove. Build the envHandle once + share it + -- with the shard prove FFI. + match (← Ix.Cli.CheckCmd.loadEnvAndShards manifest ixe) with + | .error e => IO.eprintln e; return 1 + | .ok (ixonEnv, shards) => + let envHandle ← match Aiur.EnvHandle.fromIxe ixe with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 + | .ok h => pure h + runShardProveNative manifest envHandle ixonEnv shards k aiurSystem compiled false | some ixe, some manifest, none => - Ix.Cli.CheckCmd.runShardManifestAll manifest ixe runOne + -- IxVM-native all-shards prove. Same envHandle reused across + -- every shard. + match (← Ix.Cli.CheckCmd.loadEnvAndShards manifest ixe) with + | .error e => IO.eprintln e; return 1 + | .ok (ixonEnv, shards) => + let envHandle ← match Aiur.EnvHandle.fromIxe ixe with + | .error e => IO.eprintln s!"EnvHandle.fromIxe {ixe}: {e}"; return 1 + | .ok h => pure h + let mut rc : UInt32 := 0 + for k in [0 : shards.size] do + if (← runShardProveNative manifest envHandle ixonEnv shards k + aiurSystem compiled false) != 0 then + rc := 1 + pure rc | _, _, _ => - Ix.Cli.CheckCmd.forEachClaim ixePath claimHex names keepGoing "prove" runOne + Ix.Cli.CheckCmd.forEachClaim ixePath claimHex names keepGoing "prove" false runOne end Ix.Cli.ProveCmd diff --git a/Ix/IxVM/Blake3.lean b/Ix/IxVM/Blake3.lean index 7412c6e4..fa06ded8 100644 --- a/Ix/IxVM/Blake3.lean +++ b/Ix/IxVM/Blake3.lean @@ -45,6 +45,35 @@ def blake3 := ⟦ blake3_compress_layer(load(blake3_compress_chunks(input, store(ListNode.Nil), 0, 0, store([0u8; 8]), store(IV), store(Layer.Nil)))) } + -- Flatten blake3's [[U8;4];8] output into the [U8;32] form every caller wants. + fn blake3_flat(input: ByteStream) -> [U8; 32] { + let h = blake3(input); + [h[0][0], h[0][1], h[0][2], h[0][3], + h[1][0], h[1][1], h[1][2], h[1][3], + h[2][0], h[2][1], h[2][2], h[2][3], + h[3][0], h[3][1], h[3][2], h[3][3], + h[4][0], h[4][1], h[4][2], h[4][3], + h[5][0], h[5][1], h[5][2], h[5][3], + h[6][0], h[6][1], h[6][2], h[6][3], + h[7][0], h[7][1], h[7][2], h[7][3]] + } + + -- Hash `bytes` and assert the digest equals `expected`. Used by every + -- IOBuffer-load path that verifies the pre-image of a content-addressed + -- pointer matches the bytes the prover supplied. + fn verify_bytes_against(bytes: ByteStream, expected: [U8; 32]) { + assert_eq!(blake3_flat(bytes), expected); + () + } + + -- Hash `bytes` and intern the digest into the Store. Returned pointer is + -- the canonical content-addressed `Addr` shape (`&[U8;32]`). Used by every + -- site that synthesises an address from raw bytes (e.g. `expr_addr`, + -- `leaf_hash`, `node_hash`, `cprj_content_addr`). + fn bytes_to_addr(bytes: ByteStream) -> &[U8; 32] { + store(blake3_flat(bytes)) + } + fn blake3_next_layer(layer: Layer, digest: [[U8; 4]; 8], root: G) -> (MaybeDigest, Layer) { match layer { Layer.Nil => (MaybeDigest.Some(digest), Layer.Nil), diff --git a/Ix/IxVM/ClaimHarness.lean b/Ix/IxVM/ClaimHarness.lean index 1aff93d5..55e29ce1 100644 --- a/Ix/IxVM/ClaimHarness.lean +++ b/Ix/IxVM/ClaimHarness.lean @@ -124,19 +124,45 @@ private def hintToG : Lean.ReducibilityHints → Aiur.G | .abbrev => .ofNat 0xFFFFFFFF | .regular n => .ofNat (min (1 + n.toNat) 0xFFFFFFFE) +/-! ## IxVM IOBuffer interface + +The host seeds blake3-keyed payloads on six channels; the Aiur kernel +consumes them via `io_get_info` + `#read_byte_stream`. One value shape +per channel — no overloading, no in-band discriminators. + +Tiered by access pattern (matches kernel runtime order): + +| Tier | Channel | Purpose | Key (32 G) | Value shape | +|--------|---------|--------------------------|-------------------------|-------------------| +| Ctrl | 0 | claim wire bytes | `blake3(claim_bytes)` | claim bytes | +| Ctrl | 1 | assumption tree bytes | `tree.root` | tree bytes | +| Const | 2 | constant wire bytes | const addr | const bytes | +| Const | 3 | Defn reducibility hint | Defn addr | single G | +| Blob | 4 | blob discriminator | addr | one byte (1=const, 0=blob) | +| Blob | 5 | blob raw bytes | blob addr | raw bytes | + +Tier 1 fires once per `verify_claim` invocation (claim + optional tree). +Tier 2 fires per constant traversed during `load_with_deps`. Tier 3 +fires per blob ref encountered during `build_ref_idxs_and_blobs`. + +Soundness: +* ch 0/1/2/5 — every byte stream is blake3-verified by the kernel + against its content-addressed key. +* ch 3 — semantically optional; controls WHNF reduction heuristic + only, def-eq is sound either way. +* ch 4 — sound by erasure-correctness: a lying discriminator flips + the const/blob decision and the wrong-path load downstream fails + (a "const" blob triggers a ch 2 read returning empty → blake3 + verify against the non-empty addr fails; a "blob" const dangles + references → typecheck fail). + +Channel numbers MUST stay in sync with the inlined `io_get_info` / +`#read_byte_stream` channel literals in `Ix/IxVM/Ingress.lean` and +`Ix/IxVM/Kernel/Claim.lean`. +-/ + /-- Insert all per-address entries for `addr`s satisfying `keep` into - `ioBuffer`. Each address kind lives on its own channel; the key is - always the 32-G blake3 hash, with no disambiguating suffix. - - | channel | key (32 G) | value | meaning | - |---------|------------|----------------|---------| - | 0 | `addr` | const bytes | constant data (empty marker = `addr` is a blob) | - | 1 | `addr` | raw blob bytes | referenced data (verified by Aiur via blake3) | - | 2 | `addr` | single G | Defn `ReducibilityHints` encoding | - - Blob addrs also get an empty entry on channel 0 so the kernel's - constant-vs-blob detection (`io_get_info(0, addr) ⇒ len=0`) still - works without a separate query path. -/ + `ioBuffer`. See the channel table above. -/ def addEntries (ixonEnv : Ixon.Env) (keep : Address → Bool) (ioBuffer : Aiur.IOBuffer) : Aiur.IOBuffer := Id.run do let mut ioBuffer := ioBuffer @@ -146,18 +172,21 @@ def addEntries (ixonEnv : Ixon.Env) (keep : Address → Bool) -- serialized form the lazy entry holds — no materialization needed. let bytes := lc.rawBytes let key : Array Aiur.G := addr.hash.data.map .ofUInt8 - ioBuffer := ioBuffer.extend 0 key (bytes.data.map .ofUInt8) + ioBuffer := ioBuffer.extend 2 key (bytes.data.map .ofUInt8) + -- Discriminator: this addr resolves to a constant. + ioBuffer := ioBuffer.extend 4 key #[.ofNat 1] for (addr, rawBytes) in ixonEnv.blobs do if !keep addr then continue let key : Array Aiur.G := addr.hash.data.map .ofUInt8 - ioBuffer := ioBuffer.extend 1 key (rawBytes.data.map fun b => .ofNat b.toNat) - ioBuffer := ioBuffer.extend 0 key #[] + ioBuffer := ioBuffer.extend 5 key (rawBytes.data.map fun b => .ofNat b.toNat) + -- Discriminator: this addr resolves to a blob. + ioBuffer := ioBuffer.extend 4 key #[.ofNat 0] for (_, named) in ixonEnv.named do if !keep named.addr then continue match named.constMeta with | .defn _ _ hints _ _ _ _ _ => let key : Array Aiur.G := named.addr.hash.data.map .ofUInt8 - ioBuffer := ioBuffer.extend 2 key #[hintToG hints] + ioBuffer := ioBuffer.extend 3 key #[hintToG hints] | _ => pure () return ioBuffer @@ -189,7 +218,7 @@ private def seedTreeAt (root : Address) match trees.get? root with | some tree => let bytes := Ix.AssumptionTree.ser tree - .ok (ioBuffer.extend 0 (addrKey tree.root) (bytes.data.map .ofUInt8)) + .ok (ioBuffer.extend 1 (addrKey tree.root) (bytes.data.map .ofUInt8)) | none => .error s!"no assumption tree supplied for root {root}" /-- Build the witness for `verify_claim` against `claim`. diff --git a/Ix/IxVM/Convert.lean b/Ix/IxVM/Convert.lean index b9cbd972..881ee9f2 100644 --- a/Ix/IxVM/Convert.lean +++ b/Ix/IxVM/Convert.lean @@ -53,12 +53,16 @@ def convert := ⟦ -- Universe conversion: Ixon Univ -> KLevel -- ============================================================================ - fn convert_univ(u: Univ) -> KLevel { - match u { + -- Take `&Univ` (pointer) to shrink the per-row input width — Univ is a + -- 5-variant enum, by-value passing taxes every row with the widest + -- arm's columns. Mirror the `reference_aiur_pass_pointer_not_value` + -- pattern already used for `convert_expr(e: &Expr)`. + fn convert_univ(u: &Univ) -> KLevel { + match load(u) { Univ.Zero => KLevel.Zero, - Univ.Succ(&inner) => KLevel.Succ(store(convert_univ(inner))), - Univ.Max(&a, &b) => KLevel.Max(store(convert_univ(a)), store(convert_univ(b))), - Univ.IMax(&a, &b) => KLevel.IMax(store(convert_univ(a)), store(convert_univ(b))), + Univ.Succ(inner) => KLevel.Succ(store(convert_univ(inner))), + Univ.Max(a, b) => KLevel.Max(store(convert_univ(a)), store(convert_univ(b))), + Univ.IMax(a, b) => KLevel.IMax(store(convert_univ(a)), store(convert_univ(b))), Univ.Var(idx) => KLevel.Param(flatten_u64(idx)), } } @@ -70,8 +74,8 @@ def convert := ⟦ ListNode.Cons(idx, rest) => -- universe indices are small; walk with a field index (cheap per-step -- field sub) instead of `list_lookup_u64`'s per-step U64 predecessor. - let u = load(list_lookup(univs, flatten_u64(idx))); - store(ListNode.Cons(store(convert_univ(u)), convert_univ_idxs(rest, univs))), + let u_ref = list_lookup(univs, flatten_u64(idx)); + store(ListNode.Cons(store(convert_univ(u_ref)), convert_univ_idxs(rest, univs))), } } @@ -149,8 +153,8 @@ def convert := ⟦ Expr.Srt(univ_idx) => -- field-indexed walk (see `convert_univ_idxs`): avoids the per-step -- U64 predecessor of `list_lookup_u64` on this hot universe lookup. - let u = load(list_lookup(univs, flatten_u64(univ_idx))); - store(KExprNode.Srt(store(convert_univ(u)))), + let u_ref = list_lookup(univs, flatten_u64(univ_idx)); + store(KExprNode.Srt(store(convert_univ(u_ref)))), Expr.Var(idx) => store(KExprNode.BVar(flatten_u64(idx))), @@ -208,13 +212,6 @@ def convert := ⟦ } } - fn ctx_convert_expr(e: &Expr, ctx: ConvertCtx) -> KExpr { - match ctx { - ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => - convert_expr(e, sharing, ref_idxs, recur_idxs, lit_blobs, univs), - } - } - -- ============================================================================ -- Recursor rule conversion -- ============================================================================ @@ -233,11 +230,14 @@ def convert := ⟦ RecursorRule.Mk(nfields, rhs) => match load(rule_ctor_idxs) { ListNode.Cons(ctor_idx, rest_ctor_idxs) => - let krhs = ctx_convert_expr(rhs, ctx); - let krule = KRecRule.Mk(ctor_idx, flatten_u64(nfields), krhs); - store(ListNode.Cons( - krule, - convert_rules(rest_rules, rest_ctor_idxs, ctx))), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + let krhs = convert_expr(rhs, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + let krule = KRecRule.Mk(ctor_idx, flatten_u64(nfields), krhs); + store(ListNode.Cons( + krule, + convert_rules(rest_rules, rest_ctor_idxs, ctx))), + }, }, }, } @@ -248,73 +248,91 @@ def convert := ⟦ -- ============================================================================ fn convert_definition(d: Definition, ctx: ConvertCtx, hint: G) -> KConstantInfo { - match d { - Definition.Mk(kind, safety, lvls, typ, value) => - let ktyp = ctx_convert_expr(typ, ctx); - let kval = ctx_convert_expr(value, ctx); - match kind { - DefKind.Definition => - KConstantInfo.Defn(flatten_u64(lvls), ktyp, kval, safety, hint), - DefKind.Opaque => - match safety { - DefinitionSafety.Unsafe => - KConstantInfo.Opaque(flatten_u64(lvls), ktyp, kval, 1), - _ => - KConstantInfo.Opaque(flatten_u64(lvls), ktyp, kval, 0), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + match d { + Definition.Mk(kind, safety, lvls, typ, value) => + let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + let kval = convert_expr(value, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + match kind { + DefKind.Definition => + KConstantInfo.Defn(flatten_u64(lvls), ktyp, kval, safety, hint), + DefKind.Opaque => + match safety { + DefinitionSafety.Unsafe => + KConstantInfo.Opaque(flatten_u64(lvls), ktyp, kval, 1), + _ => + KConstantInfo.Opaque(flatten_u64(lvls), ktyp, kval, 0), + }, + DefKind.Theorem => + KConstantInfo.Thm(flatten_u64(lvls), ktyp, kval), }, - DefKind.Theorem => - KConstantInfo.Thm(flatten_u64(lvls), ktyp, kval), }, } } fn convert_axiom(a: Axiom, ctx: ConvertCtx) -> KConstantInfo { - match a { - Axiom.Mk(is_unsafe, lvls, typ) => - let ktyp = ctx_convert_expr(typ, ctx); - KConstantInfo.Axiom(flatten_u64(lvls), ktyp, is_unsafe), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + match a { + Axiom.Mk(is_unsafe, lvls, typ) => + let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + KConstantInfo.Axiom(flatten_u64(lvls), ktyp, is_unsafe), + }, } } fn convert_quotient(q: Quotient, ctx: ConvertCtx) -> KConstantInfo { - match q { - Quotient.Mk(kind, lvls, typ) => - let ktyp = ctx_convert_expr(typ, ctx); - KConstantInfo.Quot(flatten_u64(lvls), ktyp, kind), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + match q { + Quotient.Mk(kind, lvls, typ) => + let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + KConstantInfo.Quot(flatten_u64(lvls), ktyp, kind), + }, } } fn convert_recursor(r: Recursor, ctx: ConvertCtx, rule_ctor_idxs: List‹G›, block_addr: Addr) -> KConstantInfo { - match r { - Recursor.Mk(k, is_unsafe, lvls, params, indices, motives, minors, typ, rules) => - let ktyp = ctx_convert_expr(typ, ctx); - let krules = convert_rules(rules, rule_ctor_idxs, ctx); - KConstantInfo.Rec( - flatten_u64(lvls), ktyp, flatten_u64(params), flatten_u64(indices), - flatten_u64(motives), flatten_u64(minors), - krules, k, is_unsafe, block_addr), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + match r { + Recursor.Mk(k, is_unsafe, lvls, params, indices, motives, minors, typ, rules) => + let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + let krules = convert_rules(rules, rule_ctor_idxs, ctx); + KConstantInfo.Rec( + flatten_u64(lvls), ktyp, flatten_u64(params), flatten_u64(indices), + flatten_u64(motives), flatten_u64(minors), + krules, k, is_unsafe, block_addr), + }, } } fn convert_inductive(ind: Inductive, ctx: ConvertCtx, ctor_idxs: List‹G›, block_addr: Addr) -> KConstantInfo { - match ind { - Inductive.Mk(is_rec, is_refl, is_unsafe, lvls, params, indices, nested, typ, _) => - let ktyp = ctx_convert_expr(typ, ctx); - KConstantInfo.Induct( - flatten_u64(lvls), ktyp, flatten_u64(params), flatten_u64(indices), - ctor_idxs, is_rec, is_refl, is_unsafe, flatten_u64(nested), block_addr), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + match ind { + Inductive.Mk(is_rec, is_refl, is_unsafe, lvls, params, indices, nested, typ, _) => + let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + KConstantInfo.Induct( + flatten_u64(lvls), ktyp, flatten_u64(params), flatten_u64(indices), + ctor_idxs, is_rec, is_refl, is_unsafe, flatten_u64(nested), block_addr), + }, } } fn convert_constructor(c: Constructor, ctx: ConvertCtx, induct_idx: G) -> KConstantInfo { - match c { - Constructor.Mk(is_unsafe, lvls, cidx, params, fields, typ) => - let ktyp = ctx_convert_expr(typ, ctx); - KConstantInfo.Ctor( - flatten_u64(lvls), ktyp, induct_idx, flatten_u64(cidx), - flatten_u64(params), flatten_u64(fields), is_unsafe), + match ctx { + ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs) => + match c { + Constructor.Mk(is_unsafe, lvls, cidx, params, fields, typ) => + let ktyp = convert_expr(typ, sharing, ref_idxs, recur_idxs, lit_blobs, univs); + KConstantInfo.Ctor( + flatten_u64(lvls), ktyp, induct_idx, flatten_u64(cidx), + flatten_u64(params), flatten_u64(fields), is_unsafe), + }, } } @@ -322,9 +340,11 @@ def convert := ⟦ -- Top-level conversion -- ============================================================================ - -- Convert a single resolved input to a KConstantInfo - fn convert_one(input: ConvertInput) -> KConstantInfo { - match input { + -- Convert a single resolved input to a KConstantInfo. Takes &ConvertInput + -- (pointer) so the per-row input width is one G column, not the full + -- ConvertInput union width. + fn convert_one(input: &ConvertInput) -> KConstantInfo { + match load(input) { ConvertInput.Mk(ctx, kind) => match kind { ConvertKind.CKDefn(d, hint) => convert_definition(d, ctx, hint), @@ -342,7 +362,7 @@ def convert := ⟦ fn convert_all(inputs: List‹&ConvertInput›) -> List‹&KConstantInfo› { match load(inputs) { ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(&input, rest) => + ListNode.Cons(input, rest) => let ci = convert_one(input); store(ListNode.Cons(store(ci), convert_all(rest))), } diff --git a/Ix/IxVM/Ingress.lean b/Ix/IxVM/Ingress.lean index 5fee5918..5d038da4 100644 --- a/Ix/IxVM/Ingress.lean +++ b/Ix/IxVM/Ingress.lean @@ -7,49 +7,61 @@ public section namespace IxVM def ingress := ⟦ - -- Load a constant from IOBuffer by address, verify blake3, deserialize. + -- IOBuffer channel identifiers. See `ClaimHarness.lean` for the host-side + -- counterpart that seeds these channels. + -- ============================================================================ + -- IxVM IOBuffer interface + -- + -- The host (Lean `IxVM.ClaimHarness`) seeds blake3-keyed payloads on six + -- channels; the kernel consumes them via `io_get_info` + `#read_byte_stream`. + -- One value shape per channel — no overloading, no in-band discriminators. + -- + -- Tiered by access pattern (matches kernel runtime order): + -- + -- Tier 1 — control input (one-per-run): + -- ch 0 claim wire bytes key = blake3(claim_bytes) value = claim bytes + -- ch 1 assumption tree bytes key = tree.root value = tree bytes + -- + -- Tier 2 — per-const data: + -- ch 2 constant wire bytes key = const.addr value = const bytes + -- ch 3 Defn reducibility hint key = defn.addr value = [hint_G] + -- + -- Tier 3 — per-blob data: + -- ch 4 blob discriminator key = addr value = [1=const,0=blob] + -- ch 5 blob raw bytes key = blob.addr value = raw bytes + -- + -- Soundness: every kernel-consumed byte stream is blake3-verified + -- against its key (ch 0/1/2/5). ch 3 hint is semantically optional + -- (controls WHNF heuristic only; def-eq is sound either way). ch 4 + -- discriminator is sound by erasure-correctness: lying flips the + -- const/blob decision and the wrong-path load fails downstream. + -- + -- Per-channel access patterns are inlined at each consumer (one site + -- per channel) so the dispatch never crosses a fn boundary — channel + -- choice doesn't add Aiur per-row width tax. Each `io_get_info` + + -- `#read_byte_stream` pair appears once at the producer call site. + -- Channel numbers MUST stay in sync with `Ix/IxVM/ClaimHarness.lean`. + -- ============================================================================ + + -- Load a constant from IOBuffer by address (ch 2), verify blake3, + -- deserialize. fn load_verified_constant(addr: Addr) -> Constant { let raw = load(addr); - let (idx, len) = io_get_info(0, raw); - let bytes = #read_byte_stream(0, idx, len); - let h = blake3(bytes); - assert_eq!( - [ - h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3] - ], - raw - ); + let (idx, len) = io_get_info(2, raw); + let bytes = #read_byte_stream(2, idx, len); + let _ = verify_bytes_against(bytes, raw); let (constant, rest) = get_constant(bytes); assert_eq!(load(rest), ListNode.Nil); constant } - -- Load a blob from IOBuffer by address, verify blake3, return raw bytes. - -- Blobs live on channel 1; constants live on channel 0 with the same key. + -- Load a blob from IOBuffer by address (ch 5), verify blake3, return + -- raw bytes. fn load_verified_blob(addr: Addr) -> ByteStream { - let (idx, len) = io_get_info(1, load(addr)); - let bytes = #read_byte_stream(1, idx, len); - let h = blake3(bytes); - assert_eq!( - [ - h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3] - ], - load(addr) - ); + let raw = load(addr); + let (idx, len) = io_get_info(5, raw); + let bytes = #read_byte_stream(5, idx, len); + let _ = verify_bytes_against(bytes, raw); bytes } @@ -104,52 +116,26 @@ def ingress := ⟦ } } - -- Load reducibility hint G for a Defn at `addr`. Lives on channel 2. - -- Encoding (mirror Lean.ReducibilityHints): + -- Load reducibility hint G for a Defn at `addr` (ch 3). Encoding + -- mirrors `Lean.ReducibilityHints`: -- 0 = Opaque -- 1 + h = Regular(h) -- 0xFFFFFFFF = Abbrev - -- Caller MUST only invoke this for Defn addrs; the harness only seeds - -- channel 2 for defns. A missing key aborts execution (correct). + -- Caller MUST only invoke this for Defn addrs; the harness only + -- seeds ch 3 for Defns. A missing key aborts execution (correct). fn load_constant_hint(addr: Addr) -> G { - let (idx, len) = io_get_info(2, load(addr)); - let bytes = #read_byte_stream(2, idx, len); + let raw = load(addr); + let (idx, len) = io_get_info(3, raw); + let bytes = #read_byte_stream(3, idx, len); match load(bytes) { ListNode.Cons(b, _) => to_field(b), } } - -- Build lit_blobs by loading and verifying each blob on demand. - -- A ref is a blob if it's not in all_addrs (the constant address list). - -- For constant refs, returns an empty ByteStream (never read by conversion). - fn build_lit_blobs(refs: List‹Addr›, addr_pos_map: &RBTreeMap‹G›) -> List‹ByteStream› { - match load(refs) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(addr, rest) => - let blob = is_blob(addr, addr_pos_map); - match blob { - 1 => - let bs = load_verified_blob(addr); - store(ListNode.Cons(bs, build_lit_blobs(rest, addr_pos_map))), - 0 => - store(ListNode.Cons(store(ListNode.Nil), build_lit_blobs(rest, addr_pos_map))), - }, - } - } - - -- Check if an address is a blob: it's a blob iff it's NOT a constant, - -- i.e. absent from `addr_pos_map` (which is keyed by every constant - -- address — see `build_addr_pos_map`). Membership only; the stored - -- position value (pos+1 ≥ 1) is irrelevant here, only "present vs 0". - -- Blob addresses and constant addresses are different by design - -- (different hash preimage structures). O(log N) tree lookup. - fn is_blob(addr: Addr, addr_pos_map: &RBTreeMap‹G›) -> G { - let hit = rbtree_map_lookup_or_default(ptr_val(addr), load(addr_pos_map), 0); - match hit { - 0 => 1, - _ => 0, - } - } + -- Sentinel value stored in `addr_pos_map` for addresses known to be + -- blob refs (not constants). Beyond any honest `pos+1` so it cannot + -- collide with a real const-position encoding. + fn sentinel_blob_ref() -> G { 4294967295 } -- Extract the Muts block address from a projection ConstantInfo. -- Returns [0; 32] for non-projection constants. @@ -227,11 +213,27 @@ def ingress := ⟦ -- fall back to the content-based `address_eq` scan, which returns 0 when -- truly absent. Honest provers always intern, so the fallback adds ~0 -- rows to the honest trace; the hot path is the O(log N) tree lookup. + -- Single-map ptr_val lookup. After `build_addr_pos_map_aug`, the map + -- carries three classes of value for an address key: + -- * 0 → not registered (truly unknown OR de-interned const) + -- * SENTINEL → known blob ref (= 4294967295, beyond any honest pos+1) + -- * pos+1 → known const at position `pos` + -- The blob class is populated once per ingress by walking every + -- constant's `refs` and inserting any non-const ref with SENTINEL. + -- Blob-ref lookups (the dominant non-const-ref traffic) now hit the + -- O(log N) probe and short-circuit to 0 without scanning. + -- + -- ptr_val-key soundness: ptr equality → content equality (positive + -- direction, sound because Aiur's Store content-addresses by content). + -- Hit on either pos+1 or SENTINEL is sound by ptr equality. Miss falls + -- through to the content-based linear scan, which catches any + -- de-interned const at its true position. fn lookup_addr_pos(target: Addr, addr_pos_map: &RBTreeMap‹G›, all_addrs: List‹Addr›, pos_map: List‹G›) -> G { let hit = rbtree_map_lookup_or_default(ptr_val(target), load(addr_pos_map), 0); match hit { 0 => lookup_addr_pos_linear(target, all_addrs, pos_map), + 4294967295 => 0, _ => hit - 1, } } @@ -285,22 +287,71 @@ def ingress := ⟦ } } - -- Find the start position of a block by its block address. - fn lookup_block_start(target: Addr, block_addrs: List‹Addr›, block_starts: List‹G›) -> G { +-- Walk all constants' `refs`. For every ref whose ptr_val is NOT + -- already mapped to a const-position (= a true const-ref), insert it + -- with the BLOB sentinel `4294967295`. Result: every ref a const + -- carries is classified at build time; `lookup_addr_pos` short-circuits + -- O(N) linear scans on blob refs to O(log N) probes. + -- + -- Duplicate refs across consts hit the existing entry on subsequent + -- inserts; the probe-before-insert prevents overwriting a const's + -- pos+1 entry. The walk is O(R log N) where R = total refs in the + -- shard's closure, N = #consts + #unique-blob-refs. + fn augment_with_blob_refs(consts: List‹&Constant›, m: RBTreeMap‹G›) -> RBTreeMap‹G› { + match load(consts) { + ListNode.Nil => m, + ListNode.Cons(&c, rest) => + match c { + Constant.Mk(_, _, refs, _) => + let m1 = insert_refs_as_blobs(refs, m); + augment_with_blob_refs(rest, m1), + }, + } + } + + fn insert_refs_as_blobs(refs: List‹Addr›, m: RBTreeMap‹G›) -> RBTreeMap‹G› { + match load(refs) { + ListNode.Nil => m, + ListNode.Cons(addr, rest) => + let key = ptr_val(addr); + let hit = rbtree_map_lookup_or_default(key, m, 0); + match hit { + 0 => + -- Not yet registered: classify as blob ref via SENTINEL. + insert_refs_as_blobs(rest, rbtree_map_insert(key, sentinel_blob_ref(), m)), + _ => + -- Already a const (pos+1) or already a blob (SENTINEL): leave alone. + insert_refs_as_blobs(rest, m), + }, + } + } + +-- Index `block_addrs`/`block_starts` into a single ptr_val-keyed rbtree so + -- the per-call lookup is O(log N) instead of an O(N) parallel-list walk. + -- ptr_val keying is sound by Aiur Store content-addressing. + fn build_block_start_map(block_addrs: List‹Addr›, block_starts: List‹G›) -> RBTreeMap‹G› { + build_block_start_map_walk(block_addrs, block_starts, RBTreeMap.Nil) + } + + fn build_block_start_map_walk(block_addrs: List‹Addr›, block_starts: List‹G›, + acc: RBTreeMap‹G›) -> RBTreeMap‹G› { match load(block_addrs) { - ListNode.Nil => 0, + ListNode.Nil => acc, ListNode.Cons(addr, rest_addrs) => match load(block_starts) { ListNode.Cons(start, rest_starts) => - let eq = address_eq(target, addr); - match eq { - 1 => start, - 0 => lookup_block_start(target, rest_addrs, rest_starts), - }, + build_block_start_map_walk(rest_addrs, rest_starts, + rbtree_map_insert(ptr_val(addr), start, acc)), }, } } + -- O(log N) block-start probe. Returns 0 when the address isn't a known + -- block (mirrors the historical "not found → 0" semantics). + fn lookup_block_start(target: Addr, block_start_map: &RBTreeMap‹G›) -> G { + rbtree_map_lookup_or_default(ptr_val(target), load(block_start_map), 0) + } + -- ============================================================================ -- Layout pass: compute block start positions and total kernel size -- ============================================================================ @@ -467,19 +518,17 @@ def ingress := ⟦ fn build_pos_map( consts: List‹&Constant›, addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G›, + block_start_map: &RBTreeMap‹G›, pos: G ) -> List‹G› { - build_pos_map_walk(consts, addrs, block_addrs, block_starts, pos, + build_pos_map_walk(consts, addrs, block_start_map, pos, store(ListNode.Nil), store(ListNode.Nil)) } fn build_pos_map_walk( consts: List‹&Constant›, addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G›, + block_start_map: &RBTreeMap‹G›, pos: G, seen_mptrs: List‹G›, seen_poses: List‹G› @@ -502,7 +551,7 @@ def ingress := ⟦ 1 => let first_pos = first_pos_for_mptr(mptr, seen_mptrs, seen_poses); store(ListNode.Cons(first_pos, - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos, seen_mptrs, seen_poses))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))), 0 => let size = block_kernel_size(members); let new_seen_m = match mptr { @@ -514,12 +563,12 @@ def ingress := ⟦ _ => store(ListNode.Cons(pos, seen_poses)), }; store(ListNode.Cons(pos, - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos + size, new_seen_m, new_seen_p))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos + size, new_seen_m, new_seen_p))), }, ConstantInfo.IPrj(prj) => match prj { InductiveProj.Mk(idx, block_addr) => - let block_start = lookup_block_start(block_addr, block_addrs, block_starts); + let block_start = lookup_block_start(block_addr, block_start_map); let block_const = load_verified_constant(block_addr); match block_const { Constant.Mk(block_info, _, _, _) => @@ -527,14 +576,14 @@ def ingress := ⟦ ConstantInfo.Muts(members) => let off = member_offset(members, flatten_u64(idx)); store(ListNode.Cons(block_start + off, - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos, seen_mptrs, seen_poses))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))), }, }, }, ConstantInfo.CPrj(prj) => match prj { ConstructorProj.Mk(idx, cidx, block_addr) => - let block_start = lookup_block_start(block_addr, block_addrs, block_starts); + let block_start = lookup_block_start(block_addr, block_start_map); let block_const = load_verified_constant(block_addr); match block_const { Constant.Mk(block_info, _, _, _) => @@ -542,14 +591,14 @@ def ingress := ⟦ ConstantInfo.Muts(members) => let mem_off = member_offset(members, flatten_u64(idx)); store(ListNode.Cons(block_start + mem_off + 1 + flatten_u64(cidx), - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos, seen_mptrs, seen_poses))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))), }, }, }, ConstantInfo.RPrj(prj) => match prj { RecursorProj.Mk(idx, block_addr) => - let block_start = lookup_block_start(block_addr, block_addrs, block_starts); + let block_start = lookup_block_start(block_addr, block_start_map); let block_const = load_verified_constant(block_addr); match block_const { Constant.Mk(block_info, _, _, _) => @@ -557,14 +606,14 @@ def ingress := ⟦ ConstantInfo.Muts(members) => let off = member_offset(members, flatten_u64(idx)); store(ListNode.Cons(block_start + off, - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos, seen_mptrs, seen_poses))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))), }, }, }, ConstantInfo.DPrj(prj) => match prj { DefinitionProj.Mk(idx, block_addr) => - let block_start = lookup_block_start(block_addr, block_addrs, block_starts); + let block_start = lookup_block_start(block_addr, block_start_map); let block_const = load_verified_constant(block_addr); match block_const { Constant.Mk(block_info, _, _, _) => @@ -572,13 +621,13 @@ def ingress := ⟦ ConstantInfo.Muts(members) => let off = member_offset(members, flatten_u64(idx)); store(ListNode.Cons(block_start + off, - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos, seen_mptrs, seen_poses))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos, seen_mptrs, seen_poses))), }, }, }, _ => store(ListNode.Cons(pos, - build_pos_map_walk(rest_consts, rest_addrs, block_addrs, block_starts, pos + 1, seen_mptrs, seen_poses))), + build_pos_map_walk(rest_consts, rest_addrs, block_start_map, pos + 1, seen_mptrs, seen_poses))), }, }, }, @@ -589,13 +638,35 @@ def ingress := ⟦ -- Ref index building using position map -- ============================================================================ - fn build_ref_idxs_mapped(refs: List‹Addr›, addr_pos_map: &RBTreeMap‹G›, - all_addrs: List‹Addr›, pos_map: List‹G›) -> List‹G› { + -- Fused walk of `refs` producing both `ref_idxs` and `lit_blobs` in one + -- pass. Each ref goes through ONE rbtree probe (`addr_pos_map`) and the + -- result is interpreted as both classifications: + -- * hit == 0 (absent — de-intern soundness floor): fall back to linear + -- scan for `ref_idx`, leave `lit_blob` empty (the conservative path). + -- * hit == SENTINEL_BLOB_REF: known blob → load + decode; idx = 0. + -- * hit == pos + 1: known const → idx = pos, blob slot empty. + fn build_ref_idxs_and_blobs(refs: List‹Addr›, addr_pos_map: &RBTreeMap‹G›, + all_addrs: List‹Addr›, pos_map: List‹G›) + -> (List‹G›, List‹ByteStream›) { match load(refs) { - ListNode.Nil => store(ListNode.Nil), + ListNode.Nil => (store(ListNode.Nil), store(ListNode.Nil)), ListNode.Cons(addr, rest) => - let pos = lookup_addr_pos(addr, addr_pos_map, all_addrs, pos_map); - store(ListNode.Cons(pos, build_ref_idxs_mapped(rest, addr_pos_map, all_addrs, pos_map))), + let (rest_idxs, rest_blobs) = + build_ref_idxs_and_blobs(rest, addr_pos_map, all_addrs, pos_map); + let hit = rbtree_map_lookup_or_default(ptr_val(addr), load(addr_pos_map), 0); + match hit { + 0 => + let pos = lookup_addr_pos_linear(addr, all_addrs, pos_map); + (store(ListNode.Cons(pos, rest_idxs)), + store(ListNode.Cons(store(ListNode.Nil), rest_blobs))), + 4294967295 => + let bs = load_verified_blob(addr); + (store(ListNode.Cons(0, rest_idxs)), + store(ListNode.Cons(bs, rest_blobs))), + _ => + (store(ListNode.Cons(hit - 1, rest_idxs)), + store(ListNode.Cons(store(ListNode.Nil), rest_blobs))), + }, } } @@ -696,49 +767,51 @@ def ingress := ⟦ } } - fn canonicalize_addr_map_walk(addrs: List‹Addr›, consts: List‹&Constant›, - seen_mptrs: List‹G›, - seen_addrs: List‹Addr›) -> List‹Addr› { + -- Produce an `Addr → canon_Addr` rbtree keyed by `ptr_val(addr)`. Only + -- members of a Muts wrapper that dedupes to an earlier canonical addr + -- contribute non-trivial entries; non-Muts and primary-wrapper consts + -- map to themselves (and we skip those — `lookup_canon_addr` falls back + -- to the target unchanged on miss). + -- + -- ptr_val keying is sound because Aiur Store content-addresses every + -- pointer: a positive ptr_val match implies content equality. A miss + -- conservatively returns the target (the existing semantics for + -- non-deduped addresses). + fn build_canon_addr_map_walk(addrs: List‹Addr›, consts: List‹&Constant›, + seen_mptrs: List‹G›, + seen_addrs: List‹Addr›, + acc: RBTreeMap‹Addr›) -> RBTreeMap‹Addr› { match load(addrs) { - ListNode.Nil => store(ListNode.Nil), + ListNode.Nil => acc, ListNode.Cons(addr, rest_a) => match load(consts) { ListNode.Cons(c, rest_c) => let mptr = extract_muts_members_ptr(c); - let canon_addr = match mptr { - 0 => addr, - _ => find_canon_addr_for_mptr(mptr, seen_mptrs, seen_addrs, addr), - }; - let new_seen_mptrs = match mptr { - 0 => seen_mptrs, - _ => store(ListNode.Cons(mptr, seen_mptrs)), - }; - let new_seen_addrs = match mptr { - 0 => seen_addrs, - _ => store(ListNode.Cons(canon_addr, seen_addrs)), - }; - store(ListNode.Cons(canon_addr, - canonicalize_addr_map_walk(rest_a, rest_c, new_seen_mptrs, new_seen_addrs))), + match mptr { + 0 => build_canon_addr_map_walk(rest_a, rest_c, seen_mptrs, seen_addrs, acc), + _ => + let canon_addr = find_canon_addr_for_mptr(mptr, seen_mptrs, seen_addrs, addr); + let new_seen_mptrs = store(ListNode.Cons(mptr, seen_mptrs)); + let new_seen_addrs = store(ListNode.Cons(canon_addr, seen_addrs)); + let new_acc = rbtree_map_insert(ptr_val(addr), canon_addr, acc); + build_canon_addr_map_walk(rest_a, rest_c, new_seen_mptrs, new_seen_addrs, new_acc), + }, }, } } - fn canonicalize_addr_map(addrs: List‹Addr›, consts: List‹&Constant›) -> List‹Addr› { - canonicalize_addr_map_walk(addrs, consts, store(ListNode.Nil), store(ListNode.Nil)) + fn build_canon_addr_map(addrs: List‹Addr›, consts: List‹&Constant›) -> RBTreeMap‹Addr› { + build_canon_addr_map_walk(addrs, consts, store(ListNode.Nil), store(ListNode.Nil), RBTreeMap.Nil) } - fn lookup_canon_addr(target: Addr, all_addrs: List‹Addr›, - canon_addrs: List‹Addr›) -> Addr { - match load(all_addrs) { - ListNode.Nil => target, - ListNode.Cons(addr, rest_a) => - match load(canon_addrs) { - ListNode.Cons(canon, rest_c) => - match address_eq(target, addr) { - 1 => canon, - 0 => lookup_canon_addr(target, rest_a, rest_c), - }, - }, + -- O(log N) canon-addr probe. Miss returns target unchanged (the + -- non-deduped case is the common one). + fn lookup_canon_addr(target: Addr, canon_addr_map: &RBTreeMap‹Addr›) -> Addr { + match load(canon_addr_map) { + RBTreeMap.Nil => target, + _ => + let hit = rbtree_map_lookup_or_default(ptr_val(target), load(canon_addr_map), target); + hit, } } @@ -864,14 +937,18 @@ def ingress := ⟦ -- block by extracting the inductive's address from the recursor's typ -- (rather than heuristically matching ctor counts among refs, which fails -- when multiple in-scope inductives share the same number of ctors). + -- Returns `(rule_ctor_idxs, block_addr)`. The standalone-Recr caller + -- needs the block_addr to wrap the CKRecr input; the Muts-block caller + -- already has block_addr in scope and discards the second component. + -- Computing both together saves the standalone caller a redundant + -- `rec_typ_to_inductive_addr` + `load_verified_constant` chain. fn build_aux_recr_ctor_idxs( recr: Recursor, refs: List‹Addr›, sharing: List‹&Expr›, all_addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G› - ) -> List‹G› { + block_start_map: &RBTreeMap‹G› + ) -> (List‹G›, Addr) { match recr { Recursor.Mk(_, _, _, params, indices, motives, minors, &typ, _) => let n_skip = ((flatten_u64(params) + flatten_u64(motives)) @@ -889,12 +966,13 @@ def ingress := ⟦ Constant.Mk(bi, _, _, _) => match bi { ConstantInfo.Muts(other_members) => - let bs = lookup_block_start(block_addr, block_addrs, block_starts); + let bs = lookup_block_start(block_addr, block_start_map); -- Mutual block: each recursor's rules cover only -- its OWN inductive's ctors. Slice the global -- rule_ctor_idxs to just this member's ctors. - extract_member_ctor_idxs(other_members, bs, - flatten_u64(member_idx)), + let idxs = extract_member_ctor_idxs(other_members, bs, + flatten_u64(member_idx)); + (idxs, block_addr), }, }, }, @@ -943,8 +1021,7 @@ def ingress := ⟦ member_idx: G, refs: List‹Addr›, all_addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G›, + block_start_map: &RBTreeMap‹G›, block_addr: Addr ) -> List‹&ConvertInput› { match mc { @@ -966,8 +1043,8 @@ def ingress := ⟦ store(ListNode.Cons(store(input), store(ListNode.Nil))), 0 => let sharing = match ctx { ConvertCtx.Mk(s, _, _, _, _) => s, }; - let rule_ctor_idxs = - build_aux_recr_ctor_idxs(recr, refs, sharing, all_addrs, block_addrs, block_starts); + let (rule_ctor_idxs, _) = + build_aux_recr_ctor_idxs(recr, refs, sharing, all_addrs, block_start_map); let input = ConvertInput.Mk(ctx, ConvertKind.CKRecr(recr, rule_ctor_idxs, block_addr)); store(ListNode.Cons(store(input), store(ListNode.Nil))), }, @@ -997,17 +1074,16 @@ def ingress := ⟦ member_idx: G, refs: List‹Addr›, all_addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G›, + block_start_map: &RBTreeMap‹G›, block_addr: Addr ) -> List‹&ConvertInput› { match load(members) { ListNode.Nil => store(ListNode.Nil), ListNode.Cons(mc, rest) => let this = expand_member(mc, ctx, all_members, block_start, member_idx, - refs, all_addrs, block_addrs, block_starts, block_addr); + refs, all_addrs, block_start_map, block_addr); let more = expand_members(rest, ctx, all_members, block_start, member_idx + 1, - refs, all_addrs, block_addrs, block_starts, block_addr); + refs, all_addrs, block_start_map, block_addr); list_concat(this, more), } } @@ -1028,15 +1104,21 @@ def ingress := ⟦ cur_addrs: List‹Addr›, all_addrs: List‹Addr›, pos_map: List‹G›, - canon_addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G›, + canon_addr_map: &RBTreeMap‹Addr›, + block_start_map: &RBTreeMap‹G›, pos: G ) -> List‹&ConvertInput› { -- Built once here; threaded as the fast-path index for `lookup_addr_pos`. - let addr_pos_map = store(build_addr_pos_map(all_addrs, pos_map)); + -- The base map carries `pos+1` for each const; `augment_with_blob_refs` + -- then walks every const's `refs` and tags every previously-unregistered + -- ref with the BLOB sentinel (4294967295), so blob-ref lookups + -- short-circuit instead of falling through to the O(N) linear scan. + -- A fused single-pass version was tried and lost — Aiur's per-row width + -- tax made the merged fn more expensive than two narrower passes. + let base_map = build_addr_pos_map(all_addrs, pos_map); + let addr_pos_map = store(augment_with_blob_refs(consts, base_map)); build_convert_inputs_walk(consts, cur_addrs, all_addrs, addr_pos_map, pos_map, - canon_addrs, block_addrs, block_starts, pos, + canon_addr_map, block_start_map, pos, store(ListNode.Nil)) } @@ -1046,9 +1128,8 @@ def ingress := ⟦ all_addrs: List‹Addr›, addr_pos_map: &RBTreeMap‹G›, pos_map: List‹G›, - canon_addrs: List‹Addr›, - block_addrs: List‹Addr›, - block_starts: List‹G›, + canon_addr_map: &RBTreeMap‹Addr›, + block_start_map: &RBTreeMap‹G›, pos: G, seen_mptrs: List‹G› ) -> List‹&ConvertInput› { @@ -1072,7 +1153,7 @@ def ingress := ⟦ -- emitted). Don't advance pos. Refs to this wrapper -- resolve to canonical pos via pos_map dedup. build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, - canon_addrs, block_addrs, block_starts, pos, seen_mptrs), + canon_addr_map, block_start_map, pos, seen_mptrs), 0 => let new_seen = match mptr { 0 => seen_mptrs, @@ -1080,81 +1161,63 @@ def ingress := ⟦ }; let size = block_kernel_size(members); let canon_block_start = lookup_addr_pos(head_addr, addr_pos_map, all_addrs, pos_map); - let canon_addr = lookup_canon_addr(head_addr, all_addrs, canon_addrs); - let ref_idxs = build_ref_idxs_mapped(refs, addr_pos_map, all_addrs, pos_map); - let lit_blobs = build_lit_blobs(refs, addr_pos_map); + let canon_addr = lookup_canon_addr(head_addr, canon_addr_map); + let (ref_idxs, lit_blobs) = + build_ref_idxs_and_blobs(refs, addr_pos_map, all_addrs, pos_map); let recur_idxs = build_recur_idxs(members, canon_block_start, 0); let ctx = ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs); let expanded = expand_members(members, ctx, members, canon_block_start, 0, - refs, all_addrs, block_addrs, block_starts, canon_addr); + refs, all_addrs, block_start_map, canon_addr); let more = build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, - canon_addrs, block_addrs, block_starts, pos + size, new_seen); + canon_addr_map, block_start_map, pos + size, new_seen); list_concat(expanded, more), }, ConstantInfo.IPrj(_) => - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos, seen_mptrs), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos, seen_mptrs), ConstantInfo.CPrj(_) => - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos, seen_mptrs), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos, seen_mptrs), ConstantInfo.RPrj(_) => - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos, seen_mptrs), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos, seen_mptrs), ConstantInfo.DPrj(_) => - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos, seen_mptrs), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos, seen_mptrs), ConstantInfo.Defn(defn) => - let ref_idxs = build_ref_idxs_mapped(refs, addr_pos_map, all_addrs, pos_map); - let lit_blobs = build_lit_blobs(refs, addr_pos_map); + let (ref_idxs, lit_blobs) = + build_ref_idxs_and_blobs(refs, addr_pos_map, all_addrs, pos_map); let recur_idxs = store(ListNode.Cons(pos, store(ListNode.Nil))); let ctx = ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs); let hint = #load_constant_hint(head_addr); let input = ConvertInput.Mk(ctx, ConvertKind.CKDefn(defn, hint)); store(ListNode.Cons(store(input), - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos + 1, seen_mptrs))), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos + 1, seen_mptrs))), ConstantInfo.Axio(axio) => - let ref_idxs = build_ref_idxs_mapped(refs, addr_pos_map, all_addrs, pos_map); - let lit_blobs = build_lit_blobs(refs, addr_pos_map); + let (ref_idxs, lit_blobs) = + build_ref_idxs_and_blobs(refs, addr_pos_map, all_addrs, pos_map); let ctx = ConvertCtx.Mk(sharing, ref_idxs, store(ListNode.Nil), lit_blobs, univs); let input = ConvertInput.Mk(ctx, ConvertKind.CKAxio(axio)); store(ListNode.Cons(store(input), - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos + 1, seen_mptrs))), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos + 1, seen_mptrs))), ConstantInfo.Quot(quot) => - let ref_idxs = build_ref_idxs_mapped(refs, addr_pos_map, all_addrs, pos_map); - let lit_blobs = build_lit_blobs(refs, addr_pos_map); + let (ref_idxs, lit_blobs) = + build_ref_idxs_and_blobs(refs, addr_pos_map, all_addrs, pos_map); let ctx = ConvertCtx.Mk(sharing, ref_idxs, store(ListNode.Nil), lit_blobs, univs); let input = ConvertInput.Mk(ctx, ConvertKind.CKQuot(quot)); store(ListNode.Cons(store(input), - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos + 1, seen_mptrs))), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos + 1, seen_mptrs))), ConstantInfo.Recr(recr) => - let ref_idxs = build_ref_idxs_mapped(refs, addr_pos_map, all_addrs, pos_map); - let lit_blobs = build_lit_blobs(refs, addr_pos_map); - -- Resolve the recursor's inductive via typ-based lookup: - -- peel n_skip foralls of `recr.typ` to reach the major's - -- type, take its head, lookup `refs[head_ref_idx]`. The - -- ctor-count heuristic in `find_matching_block_addr` picks - -- the wrong block when multiple in-scope inductives share - -- the same ctor count. - let rule_ctor_idxs = build_aux_recr_ctor_idxs( - recr, refs, sharing, all_addrs, block_addrs, block_starts); - let n_skip = match recr { - Recursor.Mk(_, _, _, params, indices, motives, minors, _, _) => - ((flatten_u64(params) + flatten_u64(motives)) - + flatten_u64(minors)) + flatten_u64(indices), - }; - let typ = match recr { - Recursor.Mk(_, _, _, _, _, _, _, &typ, _) => typ, - }; - let ind_addr = rec_typ_to_inductive_addr(typ, n_skip, refs, sharing); - let ind_const = load_verified_constant(ind_addr); - let block_addr = match ind_const { - Constant.Mk(info, _, _, _) => - match info { - ConstantInfo.IPrj(prj) => - match prj { InductiveProj.Mk(_, ba) => ba, }, - }, - }; + let (ref_idxs, lit_blobs) = + build_ref_idxs_and_blobs(refs, addr_pos_map, all_addrs, pos_map); + -- `build_aux_recr_ctor_idxs` already does the typ-peel + + -- IPrj lookup to find the recursor's inductive block; + -- get block_addr from the same call instead of redoing + -- the `rec_typ_to_inductive_addr` + `load_verified_constant` + -- chain. + let (rule_ctor_idxs, block_addr) = build_aux_recr_ctor_idxs( + recr, refs, sharing, all_addrs, block_start_map); let recur_idxs = store(ListNode.Cons(pos, store(ListNode.Nil))); let ctx = ConvertCtx.Mk(sharing, ref_idxs, recur_idxs, lit_blobs, univs); let input = ConvertInput.Mk(ctx, ConvertKind.CKRecr(recr, rule_ctor_idxs, block_addr)); store(ListNode.Cons(store(input), - build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addrs, block_addrs, block_starts, pos + 1, seen_mptrs))), + build_convert_inputs_walk(rest, rest_addrs, all_addrs, addr_pos_map, pos_map, canon_addr_map, block_start_map, pos + 1, seen_mptrs))), }, }, }, @@ -1165,19 +1228,6 @@ def ingress := ⟦ -- Loading and dependency tracking -- ============================================================================ - -- Check if an address is already in a list - fn address_in_list(addr: Addr, list: List‹Addr›) -> G { - match load(list) { - ListNode.Nil => 0, - ListNode.Cons(a, rest) => - let eq = address_eq(addr, a); - match eq { - 1 => 1, - 0 => address_in_list(addr, rest), - }, - } - } - -- Recursively load constants and their transitive dependencies. -- Processes one address at a time from a worklist, deduplicating by -- checking the visited set. Blob addresses are detected via io_get_info: @@ -1200,11 +1250,20 @@ def ingress := ⟦ load_with_deps(next, rest, visited_addrs, visited_consts, visited_set), }, _ => - -- Check if this address has constant data in IOBuffer. - -- io_get_info is unconstrained; the prover provides (0, 0) for blob addresses. - -- Soundness: if the prover lies and skips a real constant, type checking will fail. - let (_, len) = io_get_info(0, load(addr)); - match len { + -- Discriminator on ch 4: 1 = const, 0 = blob. The host + -- (`addEntries`) seeds exactly one byte per addr it ships. + -- Soundness via erasure-correctness: lying flips the const/blob + -- decision, and the wrong-path load fails downstream (a "blob" + -- const won't get its bytes ingressed → refs to it dangle → + -- typecheck fail; a "const" blob triggers a ch 2 read that + -- returns empty → blake3 verify against the non-empty addr + -- fails). + let (idx, len) = io_get_info(4, load(addr)); + let kind_bytes = #read_byte_stream(4, idx, len); + let kind = match load(kind_bytes) { + ListNode.Cons(b, _) => to_field(b), + }; + match kind { 0 => -- Blob address: skip (blob values are loaded on demand in build_lit_blobs) match load(worklist) { @@ -1252,10 +1311,11 @@ def ingress := ⟦ let (all_addrs, all_consts) = load_with_deps( target_addr, store(ListNode.Nil), store(ListNode.Nil), store(ListNode.Nil), RBTreeMap.Nil); let (block_addrs, block_starts, _total) = compute_layout(all_consts, all_addrs, 0); - let pos_map_naive = build_pos_map(all_consts, all_addrs, block_addrs, block_starts, 0); + let block_start_map = store(build_block_start_map(block_addrs, block_starts)); + let pos_map_naive = build_pos_map(all_consts, all_addrs, block_start_map, 0); let pos_map = canonicalize_pos_map(all_consts, pos_map_naive); - let canon_addrs = canonicalize_addr_map(all_addrs, all_consts); - let inputs = build_convert_inputs(all_consts, all_addrs, all_addrs, pos_map, canon_addrs, block_addrs, block_starts, 0); + let canon_addr_map = store(build_canon_addr_map(all_addrs, all_consts)); + let inputs = build_convert_inputs(all_consts, all_addrs, all_addrs, pos_map, canon_addr_map, block_start_map, 0); convert_all(inputs) } @@ -1433,7 +1493,7 @@ def ingress := ⟦ -- result or a deterministic loop counter, so the resulting addresses -- are derived from already-trusted data. fn build_ctor_overrides(all_consts: List‹&Constant›, all_addrs: List‹Addr›, - block_addrs: List‹Addr›, block_starts: List‹G›) + block_start_map: &RBTreeMap‹G›) -> List‹(G, Addr)› { match load(all_consts) { ListNode.Nil => store(ListNode.Nil), @@ -1446,7 +1506,7 @@ def ingress := ⟦ ConstantInfo.IPrj(prj) => match prj { InductiveProj.Mk(idx, block_addr) => - let block_start = lookup_block_start(block_addr, block_addrs, block_starts); + let block_start = lookup_block_start(block_addr, block_start_map); let block_const = load_verified_constant(block_addr); match block_const { Constant.Mk(bi, _, _, _) => @@ -1457,14 +1517,14 @@ def ingress := ⟦ let n_ctors = inductive_ctor_count_at(members, flatten_u64(idx)); let new_pairs = build_ctor_pairs_computed(idx, block_addr, base_pos, n_ctors, 0); list_concat(new_pairs, - build_ctor_overrides(rest_c, rest_a, block_addrs, block_starts)), + build_ctor_overrides(rest_c, rest_a, block_start_map)), _ => - build_ctor_overrides(rest_c, rest_a, block_addrs, block_starts), + build_ctor_overrides(rest_c, rest_a, block_start_map), }, }, }, _ => - build_ctor_overrides(rest_c, rest_a, block_addrs, block_starts), + build_ctor_overrides(rest_c, rest_a, block_start_map), }, }, }, @@ -1520,47 +1580,9 @@ def ingress := ⟦ store(ListNode.Nil), store(ListNode.Nil)); let bytes = put_constant(cnst, store(ListNode.Nil)); - let h = blake3(bytes); - store([h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3]]) - } - - - -- Walk addrs at increasing positions; if an override exists for the - -- current position, replace the entry. Lets us inject ctor addresses - -- into the per-position address list without restructuring the rest. - fn apply_ctor_overrides(addrs: List‹Addr›, - overrides: List‹(G, Addr)›, pos: G) - -> List‹Addr› { - match load(addrs) { - ListNode.Nil => store(ListNode.Nil), - ListNode.Cons(addr, rest) => - let new_addr = lookup_override(overrides, pos, addr); - store(ListNode.Cons(new_addr, - apply_ctor_overrides(rest, overrides, pos + 1))), - } + bytes_to_addr(bytes) } - fn lookup_override(overrides: List‹(G, Addr)›, pos: G, - default: Addr) -> Addr { - match load(overrides) { - ListNode.Nil => default, - ListNode.Cons(p, rest) => - match p { - (op, oaddr) => - match op - pos { - 0 => oaddr, - _ => lookup_override(rest, pos, default), - }, - }, - } - } fn ingress_with_primitives(target_addr: Addr) -> (List‹&KConstantInfo›, List‹Addr›) { let (all_addrs, all_consts) = load_with_deps( @@ -1587,12 +1609,13 @@ def ingress := ⟦ fn finish_ingress(all_addrs: List‹Addr›, all_consts: List‹&Constant›) -> (List‹&KConstantInfo›, List‹Addr›) { let (block_addrs, block_starts, total) = compute_layout(all_consts, all_addrs, 0); - let pos_map_naive = build_pos_map(all_consts, all_addrs, block_addrs, block_starts, 0); + let block_start_map = store(build_block_start_map(block_addrs, block_starts)); + let pos_map_naive = build_pos_map(all_consts, all_addrs, block_start_map, 0); -- Canonicalize duplicate Muts wrappers (same members-Ptr) so refs -- converge AND emitted KConstantInfos share content via store dedup. let pos_map = canonicalize_pos_map(all_consts, pos_map_naive); - let canon_addrs = canonicalize_addr_map(all_addrs, all_consts); - let inputs = build_convert_inputs(all_consts, all_addrs, all_addrs, pos_map, canon_addrs, block_addrs, block_starts, 0); + let canon_addr_map = store(build_canon_addr_map(all_addrs, all_consts)); + let inputs = build_convert_inputs(all_consts, all_addrs, all_addrs, pos_map, canon_addr_map, block_start_map, 0); let k_consts = convert_all(inputs); -- Build the pos→Addr tree via two O(N) passes (non-PRJ then PRJ -- overwrites at shared positions). Replaces the prior O(N²) @@ -1602,7 +1625,7 @@ def ingress := ⟦ -- CPrj addresses via Lean's compile (non-aux ctors aren't stored in -- env.consts). We surface them via the `[3] ++ ipr_addr` IO-buffer -- side channel and inject them as tree updates. - let overrides = build_ctor_overrides(all_consts, all_addrs, block_addrs, block_starts); + let overrides = build_ctor_overrides(all_consts, all_addrs, block_start_map); let tree = apply_ctor_overrides_tree(overrides, tree); let zero_addr = store([0u8; 32]); let addrs = emit_addrs_from_tree(0, total, tree, zero_addr); diff --git a/Ix/IxVM/Kernel/Claim.lean b/Ix/IxVM/Kernel/Claim.lean index 7122431a..ccfc9d15 100644 --- a/Ix/IxVM/Kernel/Claim.lean +++ b/Ix/IxVM/Kernel/Claim.lean @@ -438,23 +438,12 @@ def claim := ⟦ -- Load + verify a claim from the IOBuffer at key=`digest`. Mirrors -- `load_verified_constant`: read bytes, recompute blake3, assert -- equality, deserialize, assert no trailing data. + -- Load + verify a claim from IOBuffer at `digest` (ch 0). Reads bytes, + -- recomputes blake3, asserts equality, deserialises. fn load_verified_claim(digest: [U8; 32]) -> Claim { let (idx, len) = io_get_info(0, digest); let bytes = #read_byte_stream(0, idx, len); - let h = blake3(bytes); - assert_eq!( - [ - h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3] - ], - digest - ); + let _ = verify_bytes_against(bytes, digest); let (claim, rest) = get_claim(bytes); assert_eq!(load(rest), ListNode.Nil); claim @@ -467,17 +456,7 @@ def claim := ⟦ -- ============================================================================ fn expr_addr(e_ref: &Expr) -> Addr { let bytes = put_expr(load(e_ref), store(ListNode.Nil)); - let h = blake3(bytes); - store([ - h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3] - ]) + bytes_to_addr(bytes) } -- ============================================================================ @@ -728,33 +707,13 @@ def claim := ⟦ fn leaf_hash(addr: Addr) -> Addr { let tail = put_address(addr, store(ListNode.Nil)); let bytes = store(ListNode.Cons(0u8, tail)); - let h = blake3(bytes); - store([ - h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3] - ]) + bytes_to_addr(bytes) } fn node_hash(l: Addr, r: Addr) -> Addr { let tail = put_address(l, put_address(r, store(ListNode.Nil))); let bytes = store(ListNode.Cons(1u8, tail)); - let h = blake3(bytes); - store([ - h[0][0], h[0][1], h[0][2], h[0][3], - h[1][0], h[1][1], h[1][2], h[1][3], - h[2][0], h[2][1], h[2][2], h[2][3], - h[3][0], h[3][1], h[3][2], h[3][3], - h[4][0], h[4][1], h[4][2], h[4][3], - h[5][0], h[5][1], h[5][2], h[5][3], - h[6][0], h[6][1], h[6][2], h[6][3], - h[7][0], h[7][1], h[7][2], h[7][3] - ]) + bytes_to_addr(bytes) } -- ============================================================================ @@ -780,8 +739,8 @@ def claim := ⟦ fn load_assumption_tree(root: Addr) -> List‹Addr› { let raw = load(root); - let (idx, len) = io_get_info(0, raw); - let bytes = #read_byte_stream(0, idx, len); + let (idx, len) = io_get_info(1, raw); + let bytes = #read_byte_stream(1, idx, len); let (tag, s) = get_tag4(bytes); let (flag, size) = tag; assert_eq!(flag, 0xE); diff --git a/Ix/IxVM/Kernel/Primitive.lean b/Ix/IxVM/Kernel/Primitive.lean index 6462e3be..2254f08b 100644 --- a/Ix/IxVM/Kernel/Primitive.lean +++ b/Ix/IxVM/Kernel/Primitive.lean @@ -1152,10 +1152,27 @@ def primitive := ⟦ } } + -- Binary exponentiation. Replaces the old O(exp) recursive + -- `klimbs_mul(base, klimbs_pow(base, klimbs_dec(exp)))` body, which + -- created one per-fn memo row per exponent step and OOM'd for + -- non-trivial exponents. Recursion depth is `log2(exp)` — for + -- `exp = 2^32` that's 32 memo entries instead of 4 billion. + -- + -- Both `klimbs_div2` (= `klimbs_div(exp, 2)`) and `klimbs_is_odd` + -- (= `klimbs_mod(exp, 2) != 0`) route through `klimbs_div_mod`, which + -- is itself native (unconstrained_big_uint_div_mod) — so the + -- division per step is O(1) work. fn klimbs_pow(base: KLimbs, exp: KLimbs) -> KLimbs { match klimbs_is_zero(exp) { 1 => store(ListNode.Cons([1u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))), - 0 => klimbs_mul(base, klimbs_pow(base, klimbs_dec(exp))), + 0 => + let two = store(ListNode.Cons([2u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8], store(ListNode.Nil))); + let (half, r) = klimbs_div_mod(exp, two); + let sq = klimbs_pow(klimbs_normalize(klimbs_mul(base, base)), klimbs_normalize(half)); + match klimbs_is_zero(r) { + 1 => sq, + 0 => klimbs_mul(base, sq), + }, } } diff --git a/Main.lean b/Main.lean index e72ae1e8..b1ee08f4 100644 --- a/Main.lean +++ b/Main.lean @@ -1,6 +1,7 @@ --import Ix.Cli.StoreCmd import Ix.Cli.AddrOfCmd import Ix.Cli.CheckCmd +import Ix.Cli.CodegenCmd import Ix.Cli.CheckRsCmd import Ix.Cli.ClaimCmd import Ix.Cli.CompileCmd @@ -32,6 +33,7 @@ def ixCmd : Cli.Cmd := `[Cli| profileCmd; proveCmd; shardCmd; + codegenCmd; verifyCmd; addrOfCmd; ingressCmd; diff --git a/Tests/Ix/IxVM.lean b/Tests/Ix/IxVM.lean index 41c7ac42..46af36c5 100644 --- a/Tests/Ix/IxVM.lean +++ b/Tests/Ix/IxVM.lean @@ -44,6 +44,13 @@ public theorem nat_lor_lit : Nat.lor 0xf0 0x0f = 0xff := rfl public theorem nat_xor_lit : Nat.xor 0xff 0x0f = 0xf0 := rfl public theorem nat_shl_lit : Nat.shiftLeft 1 8 = 256 := rfl public theorem nat_shr_lit : Nat.shiftRight 256 4 = 16 := rfl +-- Synthetic: exercises `klimbs_pow` at a non-trivial exponent so the cost +-- of the current O(exp) recursive implementation shows up in the FFT pin. +-- Sized to terminate under typical caps with the current O(exp) body — a +-- proxy for the eventual binary-exponentiation rewrite. +set_option exponentiation.threshold 65536 in +set_option maxRecDepth 65536 in +public theorem nat_pow_big : (2 ^ 16384 : Nat) - (2 ^ 16384) = 0 := rfl -- Nat predicates (return Bool ctors) public theorem nat_beq_lit : Nat.beq 42 42 = true := rfl @@ -115,52 +122,53 @@ public def kernelCheck (name : Lean.Name) (env : Lean.Environment) : observed cost in the message so it can be pasted back. -/ private def kernelCheckEntries : List (String × Nat) := [ -- Stdlib - ("HEq", 1_715_513), - ("HEq.rec", 2_681_137), - ("Eq.rec", 2_575_090), - ("Nat", 1_857_572), - ("Nat.add", 12_973_039), - ("Nat.add_comm", 54_350_110), - ("Nat.decEq", 68_538_632), - ("Nat.decLe", 191_354_793), - ("Nat.sub_le_of_le_add", 515_056_158), + ("HEq", 1_716_804), + ("HEq.rec", 2_678_994), + ("Eq.rec", 2_573_838), + ("Nat", 1_859_519), + ("Nat.add", 12_944_048), + ("Nat.add_comm", 54_047_004), + ("Nat.decEq", 68_205_533), + ("Nat.decLe", 189_722_204), + ("Nat.sub_le_of_le_add", 510_870_092), -- Newly-unlocked targets (level_leq Géran normalize). - ("Trans.mk", 2_863_374), - ("Array.append_assoc", 2_588_157_538), - ("Vector.append", 2_661_244_845), + ("Trans.mk", 2_858_426), + ("Array.append_assoc", 2_537_478_644), + ("Vector.append", 2_607_925_682), -- Primitive reduction theorems (`IxVMPrim`) - ("IxVMPrim.nat_add_lit", 28_083_713), - ("IxVMPrim.nat_sub_lit", 33_755_207), - ("IxVMPrim.nat_mul_lit", 24_642_249), - ("IxVMPrim.nat_mul_big", 24_116_975), - ("IxVMPrim.nat_div_lit", 367_262_842), - ("IxVMPrim.nat_mod_lit", 375_958_840), - ("IxVMPrim.nat_succ_lit", 7_307_039), - ("IxVMPrim.nat_pred_lit", 14_682_236), - ("IxVMPrim.nat_gcd_lit", 605_514_332), - ("IxVMPrim.nat_land_lit", 1_019_743_752), - ("IxVMPrim.nat_lor_lit", 1_020_972_680), - ("IxVMPrim.nat_xor_lit", 1_029_804_417), - ("IxVMPrim.nat_shl_lit", 34_843_370), - ("IxVMPrim.nat_shr_lit", 372_727_841), - ("IxVMPrim.nat_beq_lit", 24_108_404), - ("IxVMPrim.nat_ble_lit", 22_469_243), - ("IxVMPrim.nat_dec_le", 198_104_580), - ("IxVMPrim.nat_dec_lt", 202_076_479), - ("IxVMPrim.nat_dec_eq", 82_352_518), - ("IxVMPrim.str_size_lit", 733_902_817), - ("IxVMPrim.bv_to_nat_lit", 577_368_692), + ("IxVMPrim.nat_add_lit", 27_965_913), + ("IxVMPrim.nat_sub_lit", 33_575_354), + ("IxVMPrim.nat_mul_lit", 24_546_472), + ("IxVMPrim.nat_mul_big", 24_048_795), + ("IxVMPrim.nat_div_lit", 363_810_437), + ("IxVMPrim.nat_mod_lit", 372_503_418), + ("IxVMPrim.nat_succ_lit", 7_306_831), + ("IxVMPrim.nat_pred_lit", 14_680_455), + ("IxVMPrim.nat_gcd_lit", 599_806_695), + ("IxVMPrim.nat_land_lit", 1_009_687_743), + ("IxVMPrim.nat_lor_lit", 1_010_490_897), + ("IxVMPrim.nat_xor_lit", 1_019_114_634), + ("IxVMPrim.nat_shl_lit", 34_666_438), + ("IxVMPrim.nat_shr_lit", 369_149_913), + ("IxVMPrim.nat_pow_big", 71_556_071), + ("IxVMPrim.nat_beq_lit", 24_057_793), + ("IxVMPrim.nat_ble_lit", 22_385_742), + ("IxVMPrim.nat_dec_le", 196_255_439), + ("IxVMPrim.nat_dec_lt", 200_202_805), + ("IxVMPrim.nat_dec_eq", 81_870_937), + ("IxVMPrim.str_size_lit", 716_854_159), + ("IxVMPrim.bv_to_nat_lit", 571_458_745), -- Mutual block + multi-member recursors - ("IxVMInd.Even", 25_965_406), - ("IxVMInd.Odd", 25_728_543), - ("IxVMInd.Even.rec", 31_629_158), - ("IxVMInd.Odd.rec", 31_628_265), + ("IxVMInd.Even", 25_857_751), + ("IxVMInd.Odd", 25_617_894), + ("IxVMInd.Even.rec", 31_430_086), + ("IxVMInd.Odd.rec", 31_429_183), -- Nested inductive + aux recursor (Tree.mk : List Tree → Tree) - ("IxVMInd.Tree", 2_634_462), - ("IxVMInd.Tree.rec", 4_870_642), + ("IxVMInd.Tree", 2_641_130), + ("IxVMInd.Tree.rec", 4_866_817), -- Edge cases from prelude - ("String.Internal.append", 725_415_461), - ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 1_091_354_031), + ("String.Internal.append", 708_332_683), + ("_private.Init.Prelude.0.Lean.extractMainModule._unsafe_rec", 1_064_762_809), ] private def nameOfString (str : String) : Lean.Name := diff --git a/crates/aiur/src/execute.rs b/crates/aiur/src/execute.rs index 11fc4df4..7732f031 100644 --- a/crates/aiur/src/execute.rs +++ b/crates/aiur/src/execute.rs @@ -16,12 +16,12 @@ use crate::{ pub struct QueryRecord { pub function_queries: Vec, pub memory_queries: FxIndexMap, - pub(crate) bytes1_queries: Bytes1Queries, - pub(crate) bytes2_queries: Bytes2Queries, + pub bytes1_queries: Bytes1Queries, + pub bytes2_queries: Bytes2Queries, } impl QueryRecord { - fn new(toplevel: &Toplevel) -> Self { + pub fn new(toplevel: &Toplevel) -> Self { let function_queries = toplevel .functions .iter() @@ -53,7 +53,7 @@ pub struct IOBuffer { impl IOBuffer { #[inline] - pub(crate) fn get_info( + pub fn get_info( &self, channel: G, key: &[G], @@ -74,7 +74,7 @@ impl IOBuffer { Ok(()) } #[inline] - pub(crate) fn read( + pub fn read( &self, channel: G, idx: usize, @@ -113,6 +113,9 @@ pub enum ExecError { InvalidIOKey, IOMappingAlreadySet, IOReadOutOfBounds { idx: usize, len: usize }, + /// Dispatched a `fun_idx` that the codegen'd kernel doesn't know. + /// Generated by `execute_generated` in `crate::ix::aiur_ixvm`. + InvalidFunIdx(usize), } impl std::fmt::Display for ExecError { @@ -150,6 +153,7 @@ impl std::fmt::Display for ExecError { Self::IOReadOutOfBounds { idx, len } => { write!(f, "IO read out of bounds: idx={idx}, len={len}") }, + Self::InvalidFunIdx(idx) => write!(f, "invalid fun_idx {idx}"), } } } @@ -655,7 +659,7 @@ impl Function { } } -fn bytes1_execute( +pub fn bytes1_execute( byte: usize, op: &Bytes1Op, map: &mut Vec, @@ -664,7 +668,7 @@ fn bytes1_execute( map.extend(Bytes1.execute(op, &[map[byte]], record)); } -fn bytes2_execute( +pub fn bytes2_execute( i: usize, j: usize, op: &Bytes2Op, @@ -674,6 +678,187 @@ fn bytes2_execute( map.extend(Bytes2.execute(op, &[map[i], map[j]], record)); } +// ============================================================================ +// Per-op value-returning helpers for the codegen'd kernel. +// +// The interpreter routes byte ops through `bytes{1,2}_execute(idx, op, +// &mut Vec, record)` which `extends` the Vec with the gadget's +// output. The codegen'd kernel doesn't keep a `Vec` value stack +// (every Aiur ValIdx is a real Rust local), so the wrappers below let +// it consume gadget outputs as fixed-size arrays / tuples / single Gs +// without an allocating Vec per op. +// +// Each helper bumps the same `bytes{1,2}_queries` channel as the +// interpreter's `Bytes{1,2}::execute` arm, so QueryRecord parity is +// preserved bit-for-bit. +// ============================================================================ + +#[inline] +pub fn bytes1_bit_decompose_value( + byte: G, + record: &mut QueryRecord, +) -> [G; 8] { + record.bytes1_queries.bump_bit_decomposition(&byte); + let byte_u64 = byte.as_canonical_u64(); + [ + G::from_bool(byte_u64 & 1 == 1), + G::from_bool(byte_u64 >> 1 & 1 == 1), + G::from_bool(byte_u64 >> 2 & 1 == 1), + G::from_bool(byte_u64 >> 3 & 1 == 1), + G::from_bool(byte_u64 >> 4 & 1 == 1), + G::from_bool(byte_u64 >> 5 & 1 == 1), + G::from_bool(byte_u64 >> 6 & 1 == 1), + G::from_bool(byte_u64 >> 7 & 1 == 1), + ] +} + +/// IxVM kernel doesn't emit `Op::U8ShiftLeft` today; kept for codegen +/// of other toplevels that might. +#[inline] +#[allow(dead_code)] +pub fn bytes1_shift_left_value( + byte: G, + record: &mut QueryRecord, +) -> G { + record.bytes1_queries.bump_shift_left(&byte); + Bytes1::shift_left(&byte) +} + +/// IxVM kernel doesn't emit `Op::U8ShiftRight` today; kept for +/// codegen of other toplevels. +#[inline] +#[allow(dead_code)] +pub fn bytes1_shift_right_value( + byte: G, + record: &mut QueryRecord, +) -> G { + record.bytes1_queries.bump_shift_right(&byte); + Bytes1::shift_right(&byte) +} + +#[inline] +pub fn bytes2_xor_value(a: G, b: G, record: &mut QueryRecord) -> G { + record.bytes2_queries.bump_xor(&a, &b); + Bytes2::xor(&a, &b) +} + +#[inline] +pub fn bytes2_and_value(a: G, b: G, record: &mut QueryRecord) -> G { + record.bytes2_queries.bump_and(&a, &b); + Bytes2::and(&a, &b) +} + +#[inline] +pub fn bytes2_or_value(a: G, b: G, record: &mut QueryRecord) -> G { + record.bytes2_queries.bump_or(&a, &b); + Bytes2::or(&a, &b) +} + +#[inline] +pub fn bytes2_less_than_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> G { + record.bytes2_queries.bump_less_than(&a, &b); + Bytes2::less_than(&a, &b) +} + +/// IxVM kernel doesn't emit `Op::U8Mul` today; kept for codegen of +/// other toplevels. +#[inline] +#[allow(dead_code)] +pub fn bytes2_mul_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> (G, G) { + record.bytes2_queries.bump_mul(&a, &b); + Bytes2::mul(&a, &b) +} + +#[inline] +pub fn bytes2_chain_rotr7_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> (G, G, G) { + record.bytes2_queries.bump_chain_rotr7(&a, &b); + Bytes2::chain_rotr7(&a, &b) +} + +#[inline] +pub fn bytes2_chain_rotr4_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> (G, G, G) { + record.bytes2_queries.bump_chain_rotr4(&a, &b); + Bytes2::chain_rotr4(&a, &b) +} + +/// Bumps `bytes2_queries.add` and returns the full `(low, carry)` +/// pair. The constrained-mode gadget only LOOKUPS `low` from the +/// chip; carry is derived natively. The codegen path uses this +/// helper so the add gadget runs exactly once. +#[inline] +pub fn bytes2_add_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> (G, G) { + record.bytes2_queries.bump_add(&a, &b); + Bytes2::add(&a, &b) +} + +#[inline] +pub fn bytes2_sub_value( + a: G, + b: G, + record: &mut QueryRecord, +) -> (G, G) { + record.bytes2_queries.bump_sub(&a, &b); + Bytes2::sub(&a, &b) +} + +/// Re-exports for the codegen'd kernel (`ix::aiur_ixvm`). The generated +/// code names these as `aiur::execute::*`; we re-export them `pub` here +/// so an external `ix` crate can see them. `CodegenBytes1Op` and +/// `CodegenBytes2Op` aren't re-exported here because the generated +/// kernel no longer references them (per-op value helpers above +/// replaced the byte-op enum dispatch). +pub use crate::gadgets::bytes1::Bytes1 as CodegenBytes1; +pub use crate::gadgets::bytes2::Bytes2 as CodegenBytes2; + +/// Helper extracted for the codegen'd kernel: compute the unconstrained +/// BigUint div-mod and return `(q_ptr, r_ptr)`. Same side effects on +/// `record.memory_queries` as the inlined `Op::UnconstrainedBigUintDivMod` +/// arm in the interpreter. +pub fn unconstrained_big_uint_div_mod_helper( + a_ptr: G, + b_ptr: G, + record: &mut QueryRecord, +) -> Result<(G, G), ExecError> { + let a_limbs = read_klimbs_u64(&record.memory_queries, a_ptr) + .map_err(ExecError::UnconstrainedBigUintDivModFailed)?; + let b_limbs = read_klimbs_u64(&record.memory_queries, b_ptr) + .map_err(ExecError::UnconstrainedBigUintDivModFailed)?; + let a_big = klimbs_u64_to_biguint(&a_limbs); + let b_big = klimbs_u64_to_biguint(&b_limbs); + let (q_big, r_big) = if b_big == num_bigint::BigUint::ZERO { + (num_bigint::BigUint::ZERO, a_big.clone()) + } else { + (&a_big / &b_big, &a_big % &b_big) + }; + let q_limbs = biguint_to_klimbs_u64(&q_big); + let r_limbs = biguint_to_klimbs_u64(&r_big); + let q_ptr = build_klimbs_u64(&mut record.memory_queries, &q_limbs) + .map_err(ExecError::UnconstrainedBigUintDivModFailed)?; + let r_ptr = build_klimbs_u64(&mut record.memory_queries, &r_limbs) + .map_err(ExecError::UnconstrainedBigUintDivModFailed)?; + Ok((q_ptr, r_ptr)) +} + /// Walk a `List` chain from `head_ptr` in `memory[10]`, returning the /// u64 limbs in head-first order. Each memory[10] entry is the standard Aiur /// tagged-enum layout: `[tag, byte0..byte7, next_ptr]`. `tag == 0` = Nil diff --git a/crates/aiur/src/gadgets/bytes1.rs b/crates/aiur/src/gadgets/bytes1.rs index cc83c5c9..a874f258 100644 --- a/crates/aiur/src/gadgets/bytes1.rs +++ b/crates/aiur/src/gadgets/bytes1.rs @@ -25,9 +25,9 @@ const TRACE_WIDTH: usize = 3; const PREPROCESSED_TRACE_WIDTH: usize = 11; /// AIR implementer for arity 1 byte-related lookups. -pub(crate) struct Bytes1; +pub struct Bytes1; -pub(crate) enum Bytes1Op { +pub enum Bytes1Op { BitDecomposition, ShiftLeft, ShiftRight, @@ -205,7 +205,7 @@ impl AiurGadget for Bytes1 { } /// Accumulator of queries performed against `Bytes1`. -pub(crate) struct Bytes1Queries([[G; TRACE_WIDTH]; 256]); +pub struct Bytes1Queries([[G; TRACE_WIDTH]; 256]); impl Bytes1Queries { #[inline] @@ -213,19 +213,19 @@ impl Bytes1Queries { Self([[G::ZERO; TRACE_WIDTH]; 256]) } - fn bump_bit_decomposition(&mut self, byte: &G) { + pub(crate) fn bump_bit_decomposition(&mut self, byte: &G) { self.bump_multiplicity_for(byte, 0) } - fn bump_shift_left(&mut self, byte: &G) { + pub(crate) fn bump_shift_left(&mut self, byte: &G) { self.bump_multiplicity_for(byte, 1) } - fn bump_shift_right(&mut self, byte: &G) { + pub(crate) fn bump_shift_right(&mut self, byte: &G) { self.bump_multiplicity_for(byte, 2) } - fn bump_multiplicity_for(&mut self, byte: &G, col: usize) { + pub(crate) fn bump_multiplicity_for(&mut self, byte: &G, col: usize) { let row = usize::try_from(byte.as_canonical_u64()).unwrap(); self.0[row][col] += G::ONE; } @@ -233,18 +233,18 @@ impl Bytes1Queries { impl Bytes1 { #[inline] - pub(crate) fn bit_decompose(byte: &G) -> Vec { + pub fn bit_decompose(byte: &G) -> Vec { let byte_u64 = byte.as_canonical_u64(); (0..8).map(|i| G::from_bool((byte_u64 >> i) & 1 == 1)).collect() } #[inline] - pub(crate) fn shift_left(byte: &G) -> G { + pub fn shift_left(byte: &G) -> G { G::from_u64((byte.as_canonical_u64() << 1) & 255) } #[inline] - pub(crate) fn shift_right(byte: &G) -> G { + pub fn shift_right(byte: &G) -> G { G::from_u64(byte.as_canonical_u64() >> 1) } } diff --git a/crates/aiur/src/gadgets/bytes2.rs b/crates/aiur/src/gadgets/bytes2.rs index 949dcff8..be47be65 100644 --- a/crates/aiur/src/gadgets/bytes2.rs +++ b/crates/aiur/src/gadgets/bytes2.rs @@ -48,9 +48,9 @@ const TRACE_WIDTH: usize = 10; const PREPROCESSED_TRACE_WIDTH: usize = 16; /// AIR implementer for arity 2 byte-related lookups. -pub(crate) struct Bytes2; +pub struct Bytes2; -pub(crate) enum Bytes2Op { +pub enum Bytes2Op { Xor, Add, Mul, @@ -422,7 +422,7 @@ impl AiurGadget for Bytes2 { } /// Accumulator of queries performed against `Bytes2`. -pub(crate) struct Bytes2Queries(Box<[[G; TRACE_WIDTH]]>); +pub struct Bytes2Queries(Box<[[G; TRACE_WIDTH]]>); impl Bytes2Queries { #[inline] @@ -430,11 +430,11 @@ impl Bytes2Queries { Self(vec![[G::ZERO; TRACE_WIDTH]; 256 * 256].into_boxed_slice()) } - fn bump_xor(&mut self, i: &G, j: &G) { + pub(crate) fn bump_xor(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 0) } - fn bump_add(&mut self, i: &G, j: &G) { + pub(crate) fn bump_add(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 1) } @@ -442,35 +442,35 @@ impl Bytes2Queries { self.bump_multiplicity_for(i, j, 2) } - fn bump_and(&mut self, i: &G, j: &G) { + pub(crate) fn bump_and(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 3) } - fn bump_or(&mut self, i: &G, j: &G) { + pub(crate) fn bump_or(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 4) } - fn bump_less_than(&mut self, i: &G, j: &G) { + pub(crate) fn bump_less_than(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 5) } - pub(crate) fn bump_range_check(&mut self, i: &G, j: &G) { + pub fn bump_range_check(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 6) } - fn bump_mul(&mut self, i: &G, j: &G) { + pub(crate) fn bump_mul(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 7) } - fn bump_chain_rotr7(&mut self, i: &G, j: &G) { + pub(crate) fn bump_chain_rotr7(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 8) } - fn bump_chain_rotr4(&mut self, i: &G, j: &G) { + pub(crate) fn bump_chain_rotr4(&mut self, i: &G, j: &G) { self.bump_multiplicity_for(i, j, 9) } - fn bump_multiplicity_for(&mut self, i: &G, j: &G, col: usize) { + pub(crate) fn bump_multiplicity_for(&mut self, i: &G, j: &G, col: usize) { let i = usize::try_from(i.as_canonical_u64()).unwrap(); let j = usize::try_from(j.as_canonical_u64()).unwrap(); let row = 256 * i + j; @@ -480,14 +480,14 @@ impl Bytes2Queries { impl Bytes2 { #[inline] - pub(crate) fn xor(i: &G, j: &G) -> G { + pub fn xor(i: &G, j: &G) -> G { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); G::from_u8(i ^ j) } #[inline] - pub(crate) fn add(i: &G, j: &G) -> (G, G) { + pub fn add(i: &G, j: &G) -> (G, G) { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); let (r, o) = i.overflowing_add(j); @@ -495,21 +495,21 @@ impl Bytes2 { } #[inline] - pub(crate) fn and(i: &G, j: &G) -> G { + pub fn and(i: &G, j: &G) -> G { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); G::from_u8(i & j) } #[inline] - pub(crate) fn or(i: &G, j: &G) -> G { + pub fn or(i: &G, j: &G) -> G { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); G::from_u8(i | j) } #[inline] - pub(crate) fn sub(i: &G, j: &G) -> (G, G) { + pub fn sub(i: &G, j: &G) -> (G, G) { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); let (r, u) = i.overflowing_sub(j); @@ -517,7 +517,7 @@ impl Bytes2 { } #[inline] - pub(crate) fn less_than(i: &G, j: &G) -> G { + pub fn less_than(i: &G, j: &G) -> G { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); G::from_bool(i < j) @@ -525,7 +525,7 @@ impl Bytes2 { /// `u8 * u8 -> (low byte, high byte)`. The product fits in 16 bits. #[inline] - pub(crate) fn mul(i: &G, j: &G) -> (G, G) { + pub fn mul(i: &G, j: &G) -> (G, G) { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); let p = u16::from(i) * u16::from(j); @@ -540,7 +540,7 @@ impl Bytes2 { /// `[A0, A1+B2, B0, B1+A2]` for `A = chain_rotr7(b0,b1)`, /// `B = chain_rotr7(b2,b3)`. #[inline] - pub(crate) fn chain_rotr7_u8(i: u8, j: u8) -> (u8, u8, u8) { + pub fn chain_rotr7_u8(i: u8, j: u8) -> (u8, u8, u8) { ((i >> 7) + (j << 1), j >> 7, i << 1) } @@ -548,12 +548,12 @@ impl Bytes2 { /// of little-endian bytes. Given adjacent bytes `i`, `j`, returns /// `(i>>4 + j<<4, j>>4, i<<4)` where shifts are taken mod 256. #[inline] - pub(crate) fn chain_rotr4_u8(i: u8, j: u8) -> (u8, u8, u8) { + pub fn chain_rotr4_u8(i: u8, j: u8) -> (u8, u8, u8) { ((i >> 4) + (j << 4), j >> 4, i << 4) } #[inline] - pub(crate) fn chain_rotr7(i: &G, j: &G) -> (G, G, G) { + pub fn chain_rotr7(i: &G, j: &G) -> (G, G, G) { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); let (o0, o1, o2) = Self::chain_rotr7_u8(i, j); @@ -561,7 +561,7 @@ impl Bytes2 { } #[inline] - pub(crate) fn chain_rotr4(i: &G, j: &G) -> (G, G, G) { + pub fn chain_rotr4(i: &G, j: &G) -> (G, G, G) { let i: u8 = i.as_canonical_u64().try_into().unwrap(); let j: u8 = j.as_canonical_u64().try_into().unwrap(); let (o0, o1, o2) = Self::chain_rotr4_u8(i, j); diff --git a/crates/aiur/src/querymap.rs b/crates/aiur/src/querymap.rs index 4ae1132d..a6b0f37d 100644 --- a/crates/aiur/src/querymap.rs +++ b/crates/aiur/src/querymap.rs @@ -12,8 +12,8 @@ pub struct QueryRef<'a> { /// Mutable view of one query entry: the output is fixed at insertion, /// only the multiplicity is bumped on memo hits. pub struct QueryRefMut<'a> { - pub(crate) output: &'a [G], - pub(crate) multiplicity: &'a mut G, + pub output: &'a [G], + pub multiplicity: &'a mut G, } fn hash_g_slice(key: &[G]) -> u64 { diff --git a/crates/aiur/src/synthesis.rs b/crates/aiur/src/synthesis.rs index 8a8f1f1e..e4422dfa 100644 --- a/crates/aiur/src/synthesis.rs +++ b/crates/aiur/src/synthesis.rs @@ -16,7 +16,7 @@ use crate::{ G, bytecode::{FunIdx, Toplevel}, constraints::Constraints, - execute::IOBuffer, + execute::{ExecError, IOBuffer, QueryRecord}, function_channel, gadgets::{AiurGadget, bytes1::Bytes1, bytes2::Bytes2}, memory::Memory, @@ -174,6 +174,82 @@ impl AiurSystem { (claim, proof) } + /// IxVM-native prove: identical to `prove` except the execute step + /// is provided by the caller as `executor` (a closure that runs + /// the codegen'd Rust kernel `ix::aiur_ixvm_runner::execute_ixvm` + /// instead of the bytecode interpreter). Avoids a circular crate + /// dependency: `aiur` doesn't know about `ix`; `ix` (or its + /// downstream `ffi`) injects the executor. + /// + /// QueryRecord shape + witness construction + claim layout + proof + /// generation are all unchanged — the proof produced here is + /// verification-compatible with one produced by `prove`. + #[tracing::instrument(level = "info", skip_all, name = "aiur/prove_ixvm")] + pub fn prove_ixvm( + &self, + fri_parameters: FriParameters, + fun_idx: FunIdx, + input: &[G], + io_buffer: &mut IOBuffer, + executor: F, + ) -> (Vec, Proof) + where + F: FnOnce( + &Toplevel, + FunIdx, + Vec, + &mut IOBuffer, + ) -> Result<(QueryRecord, Vec), ExecError>, + { + tracing_texray::examine_current(); + let _g = tracing::info_span!("aiur/execute_ixvm").entered(); + let (query_record, output) = + executor(&self.toplevel, fun_idx, input.to_vec(), io_buffer) + .expect("IxVM-native Aiur execution failed during prove_ixvm"); + drop(_g); + + let _g = tracing::info_span!("aiur/witness").entered(); + let functions = + (0..self.toplevel.functions.len()).into_par_iter().filter_map(|idx| { + if self.toplevel.functions[idx].constrained { + Some(CircuitType::Function { idx }) + } else { + None + } + }); + let memories = self + .toplevel + .memory_sizes + .par_iter() + .map(|&width| CircuitType::Memory { width }); + let gadgets = [CircuitType::Bytes1, CircuitType::Bytes2].into_par_iter(); + let witness_data = functions + .chain(memories) + .chain(gadgets) + .map(|circuit_type| match circuit_type { + CircuitType::Function { idx } => { + self.toplevel.witness_data(idx, &query_record, io_buffer) + }, + CircuitType::Memory { width } => { + Memory::witness_data(width, &query_record) + }, + CircuitType::Bytes1 => Bytes1.witness_data(&query_record), + CircuitType::Bytes2 => Bytes2.witness_data(&query_record), + }) + .collect::>(); + drop(query_record); + let (traces, lookups) = witness_data.into_iter().unzip(); + let witness = SystemWitness { traces, lookups }; + drop(_g); + + let mut claim = vec![function_channel(), G::from_usize(fun_idx)]; + claim.extend(input); + claim.extend(output); + + let proof = self.system.prove(fri_parameters, &self.key, &claim, witness); + (claim, proof) + } + #[inline] pub fn verify( &self, diff --git a/crates/ffi/Cargo.toml b/crates/ffi/Cargo.toml index aac4f212..f8ca5983 100644 --- a/crates/ffi/Cargo.toml +++ b/crates/ffi/Cargo.toml @@ -15,6 +15,7 @@ blake3 = { workspace = true } dashmap = { workspace = true, features = ["rayon"] } indexmap = { workspace = true, features = ["rayon"] } itertools = { workspace = true } +ix = { workspace = true } ix-common = { workspace = true } ix-compile = { workspace = true } ixon = { workspace = true } diff --git a/crates/ffi/src/aiur/protocol.rs b/crates/ffi/src/aiur/protocol.rs index 7450a769..c46bba0e 100644 --- a/crates/ffi/src/aiur/protocol.rs +++ b/crates/ffi/src/aiur/protocol.rs @@ -31,6 +31,8 @@ static AIUR_PROOF_CLASS: LazyLock = LazyLock::new(ExternalClass::register_with_drop::); static AIUR_SYSTEM_CLASS: LazyLock = LazyLock::new(ExternalClass::register_with_drop::); +static IX_ENV_HANDLE_CLASS: LazyLock = + LazyLock::new(ExternalClass::register_with_drop::); // ============================================================================= // Lean FFI functions @@ -169,6 +171,75 @@ extern "C" fn rs_aiur_toplevel_execute( LeanExcept::ok(result) } +/// `Bytecode.Toplevel.executeIxVM`: same shape as `rs_aiur_toplevel_execute`, +/// but routes execution through the codegen'd IxVM Rust kernel +/// (`ix::aiur_ixvm::execute_generated`) via the helper in +/// `ix::aiur_ixvm_runner::execute_ixvm`. The resulting +/// `QueryRecord` is byte-for-byte identical to the interpreter's +/// (modulo standing codegen parity invariant). +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_toplevel_execute_ixvm( + toplevel: LeanAiurToplevel>, + fun_idx: LeanNat>, + args: LeanArray>, + io_data_arr: LeanArray>, + io_map_arr: LeanArray>, +) -> LeanExcept { + let toplevel = decode_toplevel(&toplevel); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let mut io_buffer = decode_io_buffer(&io_data_arr, &io_map_arr); + + let (query_record, output) = + match ix::aiur_ixvm_runner::execute_ixvm( + &toplevel, + fun_idx, + args.map(|x| lean_unbox_g(&x)), + &mut io_buffer, + ) { + Ok(pair) => pair, + Err(err) => return LeanExcept::error_string(&err.to_string()), + }; + + // Same query-count summarisation as `rs_aiur_toplevel_execute`. + let mut query_counts: Vec<(usize, usize)> = Vec::with_capacity( + query_record.function_queries.len() + toplevel.memory_sizes.len(), + ); + let summarize = |q: &aiur::querymap::QueryMap| -> (usize, usize) { + let mut rows = 0usize; + let mut hits = 0usize; + for (_, res) in q.iter() { + let m = usize::try_from(res.multiplicity.as_canonical_u64()) + .expect("multiplicity exceeds usize"); + if m != 0 { + rows += 1; + hits += m; + } + } + (rows, hits) + }; + for queries in &query_record.function_queries { + query_counts.push(summarize(queries)); + } + for size in &toplevel.memory_sizes { + let pair = query_record.memory_queries.get(size).map_or((0, 0), summarize); + query_counts.push(pair); + } + let lean_query_counts = { + let arr = LeanArray::alloc(query_counts.len()); + for (i, &(rows, hits)) in query_counts.iter().enumerate() { + let pair = + LeanProd::new(LeanOwned::box_usize(rows), LeanOwned::box_usize(hits)); + arr.set(i, pair); + } + arr + }; + + let lean_io = build_lean_io_buffer(&io_buffer); + let io_counts = LeanProd::new(lean_io, lean_query_counts); + let result = LeanProd::new(build_g_array(&output), io_counts); + LeanExcept::ok(result) +} + /// `AiurSystem.prove`: runs the prover and returns /// `Array G × Proof × Array G × Array (Array G × IOKeyInfo)` #[unsafe(no_mangle)] @@ -198,6 +269,360 @@ extern "C" fn rs_aiur_system_prove( result.into() } + +// ============================================================================= +// EnvHandle constructors + with-env FFIs (PLAN.md "EnvHandle redesign") +// ============================================================================= + +/// `Aiur.EnvHandle.fromIxe`: open and parse a `.ixe` file once, +/// return an opaque Rust-owned handle. The mmap stays alive inside +/// the handle (via per-constant `Arc` windows) for as long as +/// Lean retains the `LeanExternal` reference. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_env_handle_from_ixe( + path_bytes: LeanByteArray>, +) -> LeanExcept { + let path_str = String::from_utf8_lossy(path_bytes.as_bytes()).into_owned(); + match ix::env_handle::EnvHandle::from_ixe_path(std::path::Path::new( + &path_str, + )) { + Ok(h) => { + let lean_handle: LeanOwned = + LeanExternal::alloc(&IX_ENV_HANDLE_CLASS, h).into(); + LeanExcept::ok(lean_handle) + }, + Err(e) => LeanExcept::error_string(&format!("env handle from_ixe: {e}")), + } +} + +/// `Aiur.EnvHandle.fromBytes`: decode a serialized env blob +/// (`Ixon.serEnv` output) and harvest `anon_hints` post-decode. +/// Used by the compiled-Lean-env path (`ix check NAME` without +/// `--ixe`). +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_env_handle_from_bytes( + bytes: LeanByteArray>, +) -> LeanExcept { + match ix::env_handle::EnvHandle::from_bytes(bytes.as_bytes()) { + Ok(h) => { + let lean_handle: LeanOwned = + LeanExternal::alloc(&IX_ENV_HANDLE_CLASS, h).into(); + LeanExcept::ok(lean_handle) + }, + Err(e) => LeanExcept::error_string(&format!("env handle from_bytes: {e}")), + } +} + +/// Helper: summarise one execute's `QueryRecord` into a Lean +/// `Array (Nat × Nat)` of `(unique_rows, total_hits)` pairs, one per +/// function circuit followed by one per memory size. Mirrors the +/// summary code used by every check/prove FFI. +fn build_query_counts_array( + query_record: &aiur::execute::QueryRecord, + toplevel: &aiur::bytecode::Toplevel, +) -> LeanArray { + let mut query_counts: Vec<(usize, usize)> = Vec::with_capacity( + query_record.function_queries.len() + toplevel.memory_sizes.len(), + ); + let summarize = |q: &aiur::querymap::QueryMap| -> (usize, usize) { + let mut rows = 0usize; + let mut hits = 0usize; + for (_, res) in q.iter() { + let m = usize::try_from(res.multiplicity.as_canonical_u64()) + .expect("multiplicity exceeds usize"); + if m != 0 { + rows += 1; + hits += m; + } + } + (rows, hits) + }; + for queries in &query_record.function_queries { + query_counts.push(summarize(queries)); + } + for size in &toplevel.memory_sizes { + let pair = query_record.memory_queries.get(size).map_or((0, 0), summarize); + query_counts.push(pair); + } + let arr = LeanArray::alloc(query_counts.len()); + for (i, &(rows, hits)) in query_counts.iter().enumerate() { + let pair = + LeanProd::new(LeanOwned::box_usize(rows), LeanOwned::box_usize(hits)); + arr.set(i, pair); + } + arr +} + +/// Helper: decode a 32-byte address from a `LeanByteArray`. +fn decode_addr( + addr_bytes: &LeanByteArray>, +) -> Result { + let slice = addr_bytes.as_bytes(); + if slice.len() != 32 { + return Err(format!( + "addr_bytes: expected 32-byte address, got {} bytes", + slice.len() + )); + } + Ok( + ix_common::address::Address::from_slice(slice) + .expect("32-byte slice already length-checked"), + ) +} + +/// Helper: decode a flat 32-byte-block owned blob into `Vec
`. +fn decode_owned_blob( + owned_blob: &LeanByteArray>, +) -> Result, String> { + let bytes = owned_blob.as_bytes(); + if bytes.len() % 32 != 0 { + return Err(format!( + "owned_blob: length {} not a multiple of 32", + bytes.len() + )); + } + Ok( + bytes + .chunks_exact(32) + .map(|c| ix_common::address::Address::from_slice(c).unwrap()) + .collect(), + ) +} + +/// Run `fun_idx` with `input` + `io_buffer`, routing through either +/// the codegen'd IxVM kernel (`use_bytecode = false`) or the +/// generic Aiur bytecode interpreter (`use_bytecode = true`). +/// The bytecode interpreter doesn't require regenerating the +/// codegen'd Rust kernel after Lean-side IxVM source changes — +/// useful for tight iteration loops on `Ix/IxVM/*.lean`. +#[inline] +fn dispatch_execute( + toplevel: &aiur::bytecode::Toplevel, + fun_idx: aiur::bytecode::FunIdx, + input: Vec, + io_buffer: &mut aiur::execute::IOBuffer, + use_bytecode: bool, +) -> Result<(aiur::execute::QueryRecord, Vec), String> { + if use_bytecode { + toplevel + .execute(fun_idx, input, io_buffer) + .map_err(|e| format!("execute (bytecode): {e}")) + } else { + ix::aiur_ixvm_runner::execute_ixvm(toplevel, fun_idx, input, io_buffer) + .map_err(|e| format!("execute_ixvm: {e}")) + } +} + +/// `Bytecode.Toplevel.checkAddrWithEnv`: per-claim check against a +/// Rust-owned `EnvHandle`. `use_bytecode` selects the executor: +/// `false` = codegen'd IxVM kernel (`execute_ixvm`), +/// `true` = generic Aiur bytecode interpreter +/// (`Toplevel::execute`). +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_toplevel_check_addr_with_env( + toplevel: LeanAiurToplevel>, + fun_idx: LeanNat>, + env_handle: LeanExternal>, + addr_bytes: LeanByteArray>, + use_bytecode: bool, +) -> LeanExcept { + let toplevel = decode_toplevel(&toplevel); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let addr = match decode_addr(&addr_bytes) { + Ok(a) => a, + Err(e) => return LeanExcept::error_string(&e), + }; + let env = &env_handle.get().env; + + let (_claim, input, mut io_buffer) = + match ix::aiur_ixvm_witness::build_claim_check_witness(env, &addr) { + Ok(t) => t, + Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), + }; + + let (query_record, output) = match dispatch_execute( + &toplevel, fun_idx, input, &mut io_buffer, use_bytecode, + ) { + Ok(p) => p, + Err(e) => return LeanExcept::error_string(&e), + }; + + let lean_query_counts = build_query_counts_array(&query_record, &toplevel); + let lean_io = build_lean_io_buffer(&io_buffer); + let io_counts = LeanProd::new(lean_io, lean_query_counts); + let result = LeanProd::new(build_g_array(&output), io_counts); + LeanExcept::ok(result) +} + +/// `Bytecode.Toplevel.shardCheckWithEnv`: per-shard check against a +/// Rust-owned `EnvHandle`. See `checkAddrWithEnv` for `use_bytecode` +/// semantics. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_toplevel_shard_check_with_env( + toplevel: LeanAiurToplevel>, + fun_idx: LeanNat>, + env_handle: LeanExternal>, + owned_blob: LeanByteArray>, + use_bytecode: bool, +) -> LeanExcept { + let toplevel = decode_toplevel(&toplevel); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let owned = match decode_owned_blob(&owned_blob) { + Ok(v) => v, + Err(e) => return LeanExcept::error_string(&e), + }; + let env = &env_handle.get().env; + + let (_claim, input, mut io_buffer) = + match ix::aiur_ixvm_witness::build_shard_check_env_witness(env, &owned) { + Ok(t) => t, + Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), + }; + + let (query_record, output) = match dispatch_execute( + &toplevel, fun_idx, input, &mut io_buffer, use_bytecode, + ) { + Ok(p) => p, + Err(e) => return LeanExcept::error_string(&e), + }; + + let lean_query_counts = build_query_counts_array(&query_record, &toplevel); + let lean_io = build_lean_io_buffer(&io_buffer); + let io_counts = LeanProd::new(lean_io, lean_query_counts); + let result = LeanProd::new(build_g_array(&output), io_counts); + LeanExcept::ok(result) +} + +/// `AiurSystem.proveAddrWithEnv`: per-claim prove against a +/// Rust-owned `EnvHandle`. Returns `(claim_bytes, proof, ioBuffer)` +/// — the claim's wire bytes are serialized via `ixon::Claim::put` +/// so Lean can deserialize directly into `Ix.Claim` without +/// reconstructing it from the target addr. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_system_prove_addr_with_env( + aiur_system_obj: LeanExternal>, + fri_parameters: LeanAiurFriParameters>, + fun_idx: LeanNat>, + env_handle: LeanExternal>, + addr_bytes: LeanByteArray>, +) -> LeanExcept { + let fri_parameters = decode_fri_parameters(&fri_parameters); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let addr = match decode_addr(&addr_bytes) { + Ok(a) => a, + Err(e) => return LeanExcept::error_string(&e), + }; + let env = &env_handle.get().env; + + let (claim, input, mut io_buffer) = + match ix::aiur_ixvm_witness::build_claim_check_witness(env, &addr) { + Ok(t) => t, + Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), + }; + + let (_aiur_claim_arr, proof) = aiur_system_obj.get().prove_ixvm( + fri_parameters, + fun_idx, + &input, + &mut io_buffer, + ix::aiur_ixvm_runner::execute_ixvm, + ); + + let mut claim_bytes: Vec = Vec::new(); + claim.put(&mut claim_bytes); + let lean_claim_bytes = LeanByteArray::from_bytes(&claim_bytes); + let lean_proof: LeanOwned = + LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); + let lean_io = build_lean_io_buffer(&io_buffer); + let proof_io = LeanProd::new(lean_proof, lean_io); + let result = LeanProd::new(lean_claim_bytes, proof_io); + LeanExcept::ok(result) +} + +/// `AiurSystem.shardProveWithEnv`: per-shard prove against a +/// Rust-owned `EnvHandle`. Same `(claim_bytes, proof, ioBuffer)` +/// return shape as `proveAddrWithEnv`. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_system_shard_prove_with_env( + aiur_system_obj: LeanExternal>, + fri_parameters: LeanAiurFriParameters>, + fun_idx: LeanNat>, + env_handle: LeanExternal>, + owned_blob: LeanByteArray>, +) -> LeanExcept { + let fri_parameters = decode_fri_parameters(&fri_parameters); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let owned = match decode_owned_blob(&owned_blob) { + Ok(v) => v, + Err(e) => return LeanExcept::error_string(&e), + }; + let env = &env_handle.get().env; + + let (claim, input, mut io_buffer) = + match ix::aiur_ixvm_witness::build_shard_check_env_witness(env, &owned) { + Ok(t) => t, + Err(e) => return LeanExcept::error_string(&format!("witness build: {e}")), + }; + + let (_aiur_claim_arr, proof) = aiur_system_obj.get().prove_ixvm( + fri_parameters, + fun_idx, + &input, + &mut io_buffer, + ix::aiur_ixvm_runner::execute_ixvm, + ); + + let mut claim_bytes: Vec = Vec::new(); + claim.put(&mut claim_bytes); + let lean_claim_bytes = LeanByteArray::from_bytes(&claim_bytes); + let lean_proof: LeanOwned = + LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); + let lean_io = build_lean_io_buffer(&io_buffer); + let proof_io = LeanProd::new(lean_proof, lean_io); + let result = LeanProd::new(lean_claim_bytes, proof_io); + LeanExcept::ok(result) +} + + + +/// `AiurSystem.proveIxVM`: IxVM-native prove path. Same return shape +/// as `rs_aiur_system_prove`, but routes execution through the +/// codegen'd Rust kernel (`execute_generated`) via +/// `AiurSystem::prove_ixvm`. The resulting `Proof` is verification- +/// compatible with `rs_aiur_system_prove`. +#[unsafe(no_mangle)] +extern "C" fn rs_aiur_system_prove_ixvm( + aiur_system_obj: LeanExternal>, + fri_parameters: LeanAiurFriParameters>, + fun_idx: LeanNat>, + args: LeanArray>, + io_data_arr: LeanArray>, + io_map_arr: LeanArray>, +) -> LeanOwned { + let fri_parameters = decode_fri_parameters(&fri_parameters); + let fun_idx = lean_unbox_nat_as_usize(fun_idx.inner()); + let args = args.map(|x| lean_unbox_g(&x)); + let mut io_buffer = decode_io_buffer(&io_data_arr, &io_map_arr); + + let (claim, proof) = aiur_system_obj.get().prove_ixvm( + fri_parameters, + fun_idx, + &args, + &mut io_buffer, + ix::aiur_ixvm_runner::execute_ixvm, + ); + + let lean_proof: LeanOwned = + LeanExternal::alloc(&AIUR_PROOF_CLASS, proof).into(); + let lean_io = build_lean_io_buffer(&io_buffer); + let proof_io_tuple = LeanProd::new(lean_proof, lean_io); + let result = LeanProd::new(build_g_array(&claim), proof_io_tuple); + result.into() +} + + + + // ============================================================================= // Helpers // ============================================================================= diff --git a/crates/ix/Cargo.toml b/crates/ix/Cargo.toml new file mode 100644 index 00000000..f651fef9 --- /dev/null +++ b/crates/ix/Cargo.toml @@ -0,0 +1,19 @@ +[package] +name = "ix" +version.workspace = true +edition.workspace = true +license.workspace = true + +[dependencies] +aiur = { workspace = true } +ix-common = { workspace = true } +ixon = { workspace = true } +dashmap = { workspace = true, features = ["rayon"] } +multi-stark = { workspace = true } +num-bigint = { workspace = true } +rayon = { workspace = true } +rustc-hash = { workspace = true } +stacker = "0.1" + +[lints] +workspace = true diff --git a/crates/ix/src/aiur_ixvm.rs b/crates/ix/src/aiur_ixvm.rs new file mode 100644 index 00000000..61040c96 --- /dev/null +++ b/crates/ix/src/aiur_ixvm.rs @@ -0,0 +1,68287 @@ +// Auto-generated by Aiur codegen. Do not edit. +// +// Mirrors `crates/aiur/src/execute.rs`'s QueryRecord side effects exactly. +// +// Skip rustfmt — this file is huge and the codegen lays it out +// for the compiler, not for humans. +#![cfg_attr(rustfmt, rustfmt::skip)] +#![allow( + unused_variables, unused_assignments, unused_mut, dead_code, + unused_parens, non_snake_case, clippy::all, +)] + +use multi_stark::p3_field::{PrimeCharacteristicRing, PrimeField64}; +use aiur::G; +use aiur::execute::{ ExecError, IOBuffer, QueryRecord, bytes1_bit_decompose_value, bytes2_xor_value, bytes2_and_value, bytes2_or_value, bytes2_less_than_value, bytes2_add_value, bytes2_sub_value, bytes2_chain_rotr7_value, bytes2_chain_rotr4_value, unconstrained_big_uint_div_mod_helper, CodegenBytes1 as Bytes1, CodegenBytes2 as Bytes2 }; + +const INPUT_SIZE_0: usize = 3; +const IN_0: usize = 3; +const OUT_0: usize = 1; +fn aiur_fn_0( + inp: [G; IN_0], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_0], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(1); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_0] = [__v_5]; + record.function_queries[0].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_3: G = G::from_u64(1); + 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 !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_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]; + record.function_queries[0].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_1], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_1.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(4); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_3.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(3); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(4); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_2.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(4); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_3.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(3); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }, + _ => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(4); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(5); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(6); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(7); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(8); + let __ret: [G; OUT_1] = [__v_8]; + record.function_queries[1].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 = 1; +fn aiur_fn_2( + inp: [G; IN_2], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_2], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_2] = [__v_8]; + 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_2] = [__v_8]; + 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_2] = [__v_8]; + 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_2] = [__v_8]; + 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_2] = [__v_8]; + 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_2] = [__v_8]; + 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_2] = [__v_8]; + 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_2] = [__v_8]; + 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_2] = [__v_8]; + record.function_queries[2].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 = 4; +fn aiur_fn_3( + inp: [G; IN_3], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_3], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_4) } else { bytes2_add_value(__v_0, __v_4, record) }; + let __v_8: G = __b2_add.0; + let __v_9: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_5) } else { bytes2_add_value(__v_1, __v_5, record) }; + let __v_10: G = __b2_add.0; + let __v_11: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_10, &__v_9) } else { bytes2_add_value(__v_10, __v_9, record) }; + let __v_12: G = __b2_add.0; + let __v_13: G = __b2_add.1; + let __v_14: G = (__v_11 + __v_13); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_6) } else { bytes2_add_value(__v_2, __v_6, record) }; + let __v_15: G = __b2_add.0; + let __v_16: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_15, &__v_14) } else { bytes2_add_value(__v_15, __v_14, record) }; + let __v_17: G = __b2_add.0; + let __v_18: G = __b2_add.1; + let __v_19: G = (__v_16 + __v_18); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_7) } else { bytes2_add_value(__v_3, __v_7, record) }; + let __v_20: G = __b2_add.0; + let __v_21: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_20, &__v_19) } else { bytes2_add_value(__v_20, __v_19, record) }; + let __v_22: G = __b2_add.0; + let __v_23: G = __b2_add.1; + let __ret: [G; OUT_3] = [__v_8, __v_12, __v_17, __v_22]; + record.function_queries[3].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_4], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = if unconstrained { Bytes2::xor(&__v_0, &__v_4) } else { bytes2_xor_value(__v_0, __v_4, record) }; + let __v_9: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) }; + let __v_10: G = if unconstrained { Bytes2::xor(&__v_2, &__v_6) } else { bytes2_xor_value(__v_2, __v_6, record) }; + let __v_11: G = if unconstrained { Bytes2::xor(&__v_3, &__v_7) } else { bytes2_xor_value(__v_3, __v_7, record) }; + let __ret: [G; OUT_4] = [__v_8, __v_9, __v_10, __v_11]; + record.function_queries[4].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_5], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = if unconstrained { Bytes2::and(&__v_0, &__v_4) } else { bytes2_and_value(__v_0, __v_4, record) }; + let __v_9: G = if unconstrained { Bytes2::and(&__v_1, &__v_5) } else { bytes2_and_value(__v_1, __v_5, record) }; + let __v_10: G = if unconstrained { Bytes2::and(&__v_2, &__v_6) } else { bytes2_and_value(__v_2, __v_6, record) }; + let __v_11: G = if unconstrained { Bytes2::and(&__v_3, &__v_7) } else { bytes2_and_value(__v_3, __v_7, record) }; + let __ret: [G; OUT_5] = [__v_8, __v_9, __v_10, __v_11]; + record.function_queries[5].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_6: usize = 16; +const IN_6: usize = 16; +const OUT_6: usize = 1; +fn aiur_fn_6( + inp: [G; IN_6], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_6], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + 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 = (__v_0 - __v_8); + let __v_17: G = (__v_1 - __v_9); + let __v_18: G = (__v_2 - __v_10); + let __v_19: G = (__v_3 - __v_11); + let __v_20: G = (__v_4 - __v_12); + let __v_21: G = (__v_5 - __v_13); + let __v_22: G = (__v_6 - __v_14); + let __v_23: G = (__v_7 - __v_15); + match __v_16.as_canonical_u64() { + 0u64 => { + match __v_17.as_canonical_u64() { + 0u64 => { + match __v_18.as_canonical_u64() { + 0u64 => { + match __v_19.as_canonical_u64() { + 0u64 => { + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + match __v_22.as_canonical_u64() { + 0u64 => { + match __v_23.as_canonical_u64() { + 0u64 => { + let __v_24: G = G::from_u64(1); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(0); + let __ret: [G; OUT_6] = [__v_24]; + record.function_queries[6].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_7: usize = 16; +const IN_7: usize = 16; +const OUT_7: usize = 9; +fn aiur_fn_7( + inp: [G; IN_7], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_7], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_8) } else { bytes2_add_value(__v_0, __v_8, record) }; + let __v_16: G = __b2_add.0; + let __v_17: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_9) } else { bytes2_add_value(__v_1, __v_9, record) }; + let __v_18: G = __b2_add.0; + let __v_19: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_18, &__v_17) } else { bytes2_add_value(__v_18, __v_17, record) }; + let __v_20: G = __b2_add.0; + let __v_21: G = __b2_add.1; + let __v_22: G = (__v_19 + __v_21); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_10) } else { bytes2_add_value(__v_2, __v_10, record) }; + let __v_23: G = __b2_add.0; + let __v_24: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_23, &__v_22) } else { bytes2_add_value(__v_23, __v_22, record) }; + let __v_25: G = __b2_add.0; + let __v_26: G = __b2_add.1; + let __v_27: G = (__v_24 + __v_26); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_11) } else { bytes2_add_value(__v_3, __v_11, record) }; + let __v_28: G = __b2_add.0; + let __v_29: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_28, &__v_27) } else { bytes2_add_value(__v_28, __v_27, record) }; + let __v_30: G = __b2_add.0; + let __v_31: G = __b2_add.1; + let __v_32: G = (__v_29 + __v_31); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_4, &__v_12) } else { bytes2_add_value(__v_4, __v_12, record) }; + let __v_33: G = __b2_add.0; + let __v_34: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_33, &__v_32) } else { bytes2_add_value(__v_33, __v_32, record) }; + let __v_35: G = __b2_add.0; + let __v_36: G = __b2_add.1; + let __v_37: G = (__v_34 + __v_36); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_5, &__v_13) } else { bytes2_add_value(__v_5, __v_13, record) }; + let __v_38: G = __b2_add.0; + let __v_39: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_38, &__v_37) } else { bytes2_add_value(__v_38, __v_37, record) }; + let __v_40: G = __b2_add.0; + let __v_41: G = __b2_add.1; + let __v_42: G = (__v_39 + __v_41); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_6, &__v_14) } else { bytes2_add_value(__v_6, __v_14, record) }; + let __v_43: G = __b2_add.0; + let __v_44: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_43, &__v_42) } else { bytes2_add_value(__v_43, __v_42, record) }; + let __v_45: G = __b2_add.0; + let __v_46: G = __b2_add.1; + let __v_47: G = (__v_44 + __v_46); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_7, &__v_15) } else { bytes2_add_value(__v_7, __v_15, record) }; + let __v_48: G = __b2_add.0; + let __v_49: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_48, &__v_47) } else { bytes2_add_value(__v_48, __v_47, record) }; + let __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_7] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; + record.function_queries[7].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_8: usize = 16; +const IN_8: usize = 16; +const OUT_8: usize = 8; +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 __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __ret: [G; OUT_8] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { 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 = __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 __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { 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_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + let __v_27: G = __r_arr[2]; + let __v_28: G = __r_arr[3]; + let __v_29: G = __r_arr[4]; + let __v_30: G = __r_arr[5]; + let __v_31: G = __r_arr[6]; + let __v_32: G = __r_arr[7]; + let __r_arr: [G; OUT_8] = { let __args: [G; IN_8] = [__v_17, __v_18, __v_19, __v_20, __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[8].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_8] = unsafe { *(result.output.as_ptr() as *const [G; OUT_8]) }; __ret } else { aiur_fn_8(__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 __ret: [G; OUT_8] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40]; + record.function_queries[8].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_9: usize = 2; +const IN_9: usize = 2; +const OUT_9: usize = 1; +fn aiur_fn_9( + inp: [G; IN_9], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_9], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(0); + let __ret: [G; OUT_9] = [__v_2]; + record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_2: G = G::from_u64(1); + let __ret: [G; OUT_9] = [__v_2]; + record.function_queries[9].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_2: G = G::from_u64(1); + let __ret: [G; OUT_9] = [__v_2]; + 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 OUT_10: usize = 8; +fn aiur_fn_10( + inp: [G; IN_10], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_10], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_0.as_canonical_u64() { + 255u64 => { + match __v_1.as_canonical_u64() { + 255u64 => { + match __v_2.as_canonical_u64() { + 255u64 => { + match __v_3.as_canonical_u64() { + 255u64 => { + match __v_4.as_canonical_u64() { + 255u64 => { + match __v_5.as_canonical_u64() { + 255u64 => { + match __v_6.as_canonical_u64() { + 255u64 => { + match __v_7.as_canonical_u64() { + 255u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(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(1); + let __v_16: G = (__v_7 + __v_15); + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(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(1); + let __v_15: G = (__v_6 + __v_14); + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(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(1); + let __v_14: G = (__v_5 + __v_13); + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + 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_4 + __v_12); + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + 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_10] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_2 + __v_10); + let __ret: [G; OUT_10] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_1 + __v_9); + let __ret: [G; OUT_10] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_0 + __v_8); + let __ret: [G; OUT_10] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[10].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_11: usize = 10; +const IN_11: usize = 10; +const OUT_11: usize = 8; +fn aiur_fn_11( + inp: [G; IN_11], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_11], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_7, &__v_9) } else { bytes2_add_value(__v_7, __v_9, record) }; + let __v_10: G = __b2_add.0; + let __v_11: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_6, &__v_8) } else { bytes2_add_value(__v_6, __v_8, record) }; + let __v_12: G = __b2_add.0; + let __v_13: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_12, &__v_11) } else { bytes2_add_value(__v_12, __v_11, record) }; + let __v_14: G = __b2_add.0; + let __v_15: G = __b2_add.1; + let __v_16: G = (__v_13 + __v_15); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_5, &__v_16) } else { bytes2_add_value(__v_5, __v_16, record) }; + let __v_17: G = __b2_add.0; + let __v_18: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_4, &__v_18) } else { bytes2_add_value(__v_4, __v_18, record) }; + let __v_19: G = __b2_add.0; + let __v_20: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_20) } else { bytes2_add_value(__v_3, __v_20, record) }; + let __v_21: G = __b2_add.0; + let __v_22: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_22) } else { bytes2_add_value(__v_2, __v_22, record) }; + let __v_23: G = __b2_add.0; + let __v_24: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_24) } else { bytes2_add_value(__v_1, __v_24, record) }; + let __v_25: G = __b2_add.0; + let __v_26: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_26) } else { bytes2_add_value(__v_0, __v_26, record) }; + let __v_27: G = __b2_add.0; + let __v_28: G = __b2_add.1; + let __ret: [G; OUT_11] = [__v_27, __v_25, __v_23, __v_21, __v_19, __v_17, __v_12, __v_10]; + record.function_queries[11].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 = 4; +fn aiur_fn_12( + inp: [G; IN_12], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_12], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_7) } else { bytes2_add_value(__v_3, __v_7, record) }; + let __v_8: G = __b2_add.0; + let __v_9: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_6) } else { bytes2_add_value(__v_2, __v_6, record) }; + let __v_10: G = __b2_add.0; + let __v_11: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_10, &__v_9) } else { bytes2_add_value(__v_10, __v_9, record) }; + let __v_12: G = __b2_add.0; + let __v_13: G = __b2_add.1; + let __v_14: G = (__v_11 + __v_13); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_5) } else { bytes2_add_value(__v_1, __v_5, record) }; + let __v_15: G = __b2_add.0; + let __v_16: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_15, &__v_14) } else { bytes2_add_value(__v_15, __v_14, record) }; + let __v_17: G = __b2_add.0; + let __v_18: G = __b2_add.1; + let __v_19: G = (__v_16 + __v_18); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_4) } else { bytes2_add_value(__v_0, __v_4, record) }; + let __v_20: G = __b2_add.0; + let __v_21: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_20, &__v_19) } else { bytes2_add_value(__v_20, __v_19, record) }; + let __v_22: G = __b2_add.0; + let __v_23: G = __b2_add.1; + let __ret: [G; OUT_12] = [__v_22, __v_17, __v_12, __v_8]; + record.function_queries[12].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_13: usize = 8; +const IN_13: usize = 8; +const OUT_13: usize = 8; +fn aiur_fn_13( + inp: [G; IN_13], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_13], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(255); + let __v_9: G = G::from_u64(255); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(255); + let __v_12: G = G::from_u64(255); + let __v_13: G = G::from_u64(255); + 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_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_16]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(255); + let __v_9: G = G::from_u64(255); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(255); + let __v_12: G = G::from_u64(255); + 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_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_15, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(255); + let __v_9: G = G::from_u64(255); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(255); + 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_13] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_14, __v_6, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(255); + let __v_9: G = G::from_u64(255); + let __v_10: G = G::from_u64(255); + 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_13] = [__v_8, __v_9, __v_10, __v_11, __v_13, __v_5, __v_6, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(255); + let __v_9: G = G::from_u64(255); + 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_13] = [__v_8, __v_9, __v_10, __v_12, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(255); + 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_13] = [__v_8, __v_9, __v_11, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + 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_13] = [__v_8, __v_10, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_0 - __v_8); + let __ret: [G; OUT_13] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[13].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_14: usize = 8; +const IN_14: usize = 8; +const OUT_14: usize = 1; +fn aiur_fn_14( + inp: [G; IN_14], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_14], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = 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() }); + } + let __v_9: G = G::from_u64(256); + let __v_10: G = (__v_9 * __v_1); + let __v_11: G = G::from_u64(65536); + let __v_12: G = (__v_11 * __v_2); + let __v_13: G = G::from_u64(16777216); + let __v_14: G = (__v_13 * __v_3); + let __v_15: G = G::from_u64(4294967296); + let __v_16: G = (__v_15 * __v_4); + let __v_17: G = G::from_u64(1099511627776); + let __v_18: G = (__v_17 * __v_5); + let __v_19: G = G::from_u64(281474976710656); + let __v_20: G = (__v_19 * __v_6); + let __v_21: G = (__v_18 + __v_20); + let __v_22: G = (__v_16 + __v_21); + let __v_23: G = (__v_14 + __v_22); + 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_14] = [__v_26]; + record.function_queries[14].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_15: usize = 0; +const IN_15: usize = 0; +const OUT_15: usize = 32; +fn aiur_fn_15( + inp: [G; IN_15], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_15], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(0); + let __v_1: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_1]; let __info = io_buffer.get_info(__v_0, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_2: G = __io_pair.0; + let __v_3: G = __io_pair.1; + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_4, __v_2, __v_3]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __v_9: G = __r_arr[3]; + let __v_10: G = __r_arr[4]; + let __v_11: G = __r_arr[5]; + let __v_12: G = __r_arr[6]; + let __v_13: G = __r_arr[7]; + let __v_14: G = __r_arr[8]; + let __v_15: G = __r_arr[9]; + let __v_16: G = __r_arr[10]; + let __v_17: G = __r_arr[11]; + let __v_18: G = __r_arr[12]; + let __v_19: G = __r_arr[13]; + let __v_20: G = __r_arr[14]; + let __v_21: G = __r_arr[15]; + let __v_22: G = __r_arr[16]; + let __v_23: G = __r_arr[17]; + let __v_24: G = __r_arr[18]; + let __v_25: G = __r_arr[19]; + let __v_26: G = __r_arr[20]; + let __v_27: G = __r_arr[21]; + let __v_28: G = __r_arr[22]; + let __v_29: G = __r_arr[23]; + let __v_30: G = __r_arr[24]; + let __v_31: G = __r_arr[25]; + let __v_32: G = __r_arr[26]; + let __v_33: G = __r_arr[27]; + let __v_34: G = __r_arr[28]; + let __v_35: G = __r_arr[29]; + let __v_36: G = __r_arr[30]; + let __v_37: G = __r_arr[31]; + let __ret: [G; OUT_15] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; + record.function_queries[15].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_16: usize = 1; +const IN_16: usize = 1; +const OUT_16: usize = 1; +fn aiur_fn_16( + inp: [G; IN_16], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_16], 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 = (__v_0 - __v_1); + let __v_3: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_2]; let __info = io_buffer.get_info(__v_3, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_4: G = __io_pair.0; + let __v_5: G = __io_pair.1; + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __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 __v_13: G = __r_arr[5]; + let __v_14: G = __r_arr[6]; + let __v_15: G = __r_arr[7]; + let __v_16: G = __r_arr[8]; + let __v_17: G = __r_arr[9]; + let __v_18: G = __r_arr[10]; + let __v_19: G = __r_arr[11]; + let __v_20: G = __r_arr[12]; + let __v_21: G = __r_arr[13]; + let __v_22: G = __r_arr[14]; + let __v_23: G = __r_arr[15]; + let __v_24: G = __r_arr[16]; + let __v_25: G = __r_arr[17]; + let __v_26: G = __r_arr[18]; + let __v_27: G = __r_arr[19]; + let __v_28: G = __r_arr[20]; + let __v_29: G = __r_arr[21]; + let __v_30: G = __r_arr[22]; + let __v_31: G = __r_arr[23]; + let __v_32: G = __r_arr[24]; + let __v_33: G = __r_arr[25]; + let __v_34: G = __r_arr[26]; + let __v_35: G = __r_arr[27]; + let __v_36: G = __r_arr[28]; + let __v_37: G = __r_arr[29]; + let __v_38: G = __r_arr[30]; + let __v_39: G = __r_arr[31]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_40: G = G::from_u64(0); + let __ret: [G; OUT_16] = [__v_40]; + record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_16] = { let __args: [G; IN_16] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[16].get_mut(&__args[..]) { 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_40: G = __r_arr[0]; + let __ret: [G; OUT_16] = [__v_40]; + record.function_queries[16].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_17: usize = 1; +const IN_17: usize = 1; +const OUT_17: usize = 32; +fn aiur_fn_17( + inp: [G; IN_17], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_17], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(103); + let __v_2: G = G::from_u64(230); + let __v_3: G = G::from_u64(9); + let __v_4: G = G::from_u64(106); + let __v_5: G = G::from_u64(133); + let __v_6: G = G::from_u64(174); + let __v_7: G = G::from_u64(103); + let __v_8: G = G::from_u64(187); + let __v_9: G = G::from_u64(114); + let __v_10: G = G::from_u64(243); + let __v_11: G = G::from_u64(110); + let __v_12: G = G::from_u64(60); + let __v_13: G = G::from_u64(58); + let __v_14: G = G::from_u64(245); + let __v_15: G = G::from_u64(79); + let __v_16: G = G::from_u64(165); + let __v_17: G = G::from_u64(127); + let __v_18: G = G::from_u64(82); + let __v_19: G = G::from_u64(14); + let __v_20: G = G::from_u64(81); + let __v_21: G = G::from_u64(140); + let __v_22: G = G::from_u64(104); + let __v_23: G = G::from_u64(5); + let __v_24: G = G::from_u64(155); + let __v_25: G = G::from_u64(171); + let __v_26: G = G::from_u64(217); + let __v_27: G = G::from_u64(131); + let __v_28: G = G::from_u64(31); + let __v_29: G = G::from_u64(25); + let __v_30: G = G::from_u64(205); + let __v_31: G = G::from_u64(224); + let __v_32: G = G::from_u64(91); + let __v_33: G = G::from_u64(1); + let __v_34: G = G::from_u64(1); + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 8] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = G::from_u64(1); + let __v_49: G = G::from_u64(1); + let __v_50: G = { let __values: [G; 34] = [__v_48, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49, __v_49]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0, __v_35, __v_36, __v_37, __v_46, __v_47, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __v_52: G = __loaded[0]; + let __v_53: G = __loaded[1]; + let __v_54: G = __loaded[2]; + let __v_55: G = __loaded[3]; + let __v_56: G = __loaded[4]; + let __v_57: G = __loaded[5]; + let __v_58: G = __loaded[6]; + let __v_59: G = __loaded[7]; + let __v_60: G = __loaded[8]; + let __v_61: G = __loaded[9]; + let __v_62: G = __loaded[10]; + let __v_63: G = __loaded[11]; + let __v_64: G = __loaded[12]; + let __v_65: G = __loaded[13]; + let __v_66: G = __loaded[14]; + let __v_67: G = __loaded[15]; + let __v_68: G = __loaded[16]; + let __v_69: G = __loaded[17]; + let __v_70: G = __loaded[18]; + let __v_71: G = __loaded[19]; + let __v_72: G = __loaded[20]; + let __v_73: G = __loaded[21]; + let __v_74: G = __loaded[22]; + let __v_75: G = __loaded[23]; + let __v_76: G = __loaded[24]; + let __v_77: G = __loaded[25]; + let __v_78: G = __loaded[26]; + let __v_79: G = __loaded[27]; + let __v_80: G = __loaded[28]; + let __v_81: G = __loaded[29]; + let __v_82: G = __loaded[30]; + let __v_83: G = __loaded[31]; + let __v_84: G = __loaded[32]; + let __v_85: G = __loaded[33]; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { 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_86: G = __r_arr[0]; + let __v_87: G = __r_arr[1]; + let __v_88: G = __r_arr[2]; + let __v_89: G = __r_arr[3]; + let __v_90: G = __r_arr[4]; + let __v_91: G = __r_arr[5]; + let __v_92: G = __r_arr[6]; + let __v_93: G = __r_arr[7]; + let __v_94: G = __r_arr[8]; + let __v_95: G = __r_arr[9]; + let __v_96: G = __r_arr[10]; + let __v_97: G = __r_arr[11]; + let __v_98: G = __r_arr[12]; + let __v_99: G = __r_arr[13]; + let __v_100: G = __r_arr[14]; + let __v_101: G = __r_arr[15]; + let __v_102: G = __r_arr[16]; + let __v_103: G = __r_arr[17]; + let __v_104: G = __r_arr[18]; + let __v_105: G = __r_arr[19]; + let __v_106: G = __r_arr[20]; + let __v_107: G = __r_arr[21]; + let __v_108: G = __r_arr[22]; + let __v_109: G = __r_arr[23]; + let __v_110: G = __r_arr[24]; + let __v_111: G = __r_arr[25]; + let __v_112: G = __r_arr[26]; + let __v_113: G = __r_arr[27]; + let __v_114: G = __r_arr[28]; + let __v_115: G = __r_arr[29]; + let __v_116: G = __r_arr[30]; + let __v_117: G = __r_arr[31]; + let __ret: [G; OUT_17] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; + record.function_queries[17].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_18: usize = 1; +const IN_18: usize = 1; +const OUT_18: usize = 32; +fn aiur_fn_18( + inp: [G; IN_18], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_18], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __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 __v_11: G = __r_arr[10]; + let __v_12: G = __r_arr[11]; + let __v_13: G = __r_arr[12]; + let __v_14: G = __r_arr[13]; + let __v_15: G = __r_arr[14]; + let __v_16: G = __r_arr[15]; + let __v_17: G = __r_arr[16]; + let __v_18: G = __r_arr[17]; + let __v_19: G = __r_arr[18]; + let __v_20: G = __r_arr[19]; + let __v_21: G = __r_arr[20]; + let __v_22: G = __r_arr[21]; + let __v_23: G = __r_arr[22]; + let __v_24: G = __r_arr[23]; + let __v_25: G = __r_arr[24]; + let __v_26: G = __r_arr[25]; + let __v_27: G = __r_arr[26]; + let __v_28: G = __r_arr[27]; + let __v_29: G = __r_arr[28]; + let __v_30: G = __r_arr[29]; + let __v_31: G = __r_arr[30]; + let __v_32: G = __r_arr[31]; + let __ret: [G; OUT_18] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + record.function_queries[18].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_19: usize = 33; +const IN_19: usize = 33; +const OUT_19: usize = 0; +fn aiur_fn_19( + inp: [G; IN_19], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_19], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_42: G = __r_arr[9]; + let __v_43: G = __r_arr[10]; + let __v_44: G = __r_arr[11]; + let __v_45: G = __r_arr[12]; + let __v_46: G = __r_arr[13]; + let __v_47: G = __r_arr[14]; + let __v_48: G = __r_arr[15]; + let __v_49: G = __r_arr[16]; + let __v_50: G = __r_arr[17]; + let __v_51: G = __r_arr[18]; + let __v_52: G = __r_arr[19]; + let __v_53: G = __r_arr[20]; + let __v_54: G = __r_arr[21]; + let __v_55: G = __r_arr[22]; + let __v_56: G = __r_arr[23]; + let __v_57: G = __r_arr[24]; + let __v_58: G = __r_arr[25]; + let __v_59: G = __r_arr[26]; + let __v_60: G = __r_arr[27]; + let __v_61: G = __r_arr[28]; + let __v_62: G = __r_arr[29]; + let __v_63: G = __r_arr[30]; + let __v_64: G = __r_arr[31]; + if (__v_33 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_1.as_canonical_u64() }); + } + if (__v_34 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_2.as_canonical_u64() }); + } + if (__v_35 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_3.as_canonical_u64() }); + } + if (__v_36 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_36.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + if (__v_37 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); + } + if (__v_38 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_6.as_canonical_u64() }); + } + if (__v_39 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_7.as_canonical_u64() }); + } + if (__v_40 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_40.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); + } + if (__v_41 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_41.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); + } + if (__v_42 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_42.as_canonical_u64(), rhs: __v_10.as_canonical_u64() }); + } + if (__v_43 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_43.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + if (__v_44 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_44.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + if (__v_45 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_13.as_canonical_u64() }); + } + if (__v_46 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_14.as_canonical_u64() }); + } + if (__v_47 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_47.as_canonical_u64(), rhs: __v_15.as_canonical_u64() }); + } + if (__v_48 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_48.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); + } + if (__v_49 != __v_17) { + return Err(ExecError::AssertEqMismatch { lhs: __v_49.as_canonical_u64(), rhs: __v_17.as_canonical_u64() }); + } + if (__v_50 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_50.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); + } + if (__v_51 != __v_19) { + return Err(ExecError::AssertEqMismatch { lhs: __v_51.as_canonical_u64(), rhs: __v_19.as_canonical_u64() }); + } + if (__v_52 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_52.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); + } + if (__v_53 != __v_21) { + return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_21.as_canonical_u64() }); + } + if (__v_54 != __v_22) { + return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_22.as_canonical_u64() }); + } + if (__v_55 != __v_23) { + return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); + } + if (__v_56 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_56.as_canonical_u64(), rhs: __v_24.as_canonical_u64() }); + } + if (__v_57 != __v_25) { + return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_25.as_canonical_u64() }); + } + if (__v_58 != __v_26) { + return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_26.as_canonical_u64() }); + } + if (__v_59 != __v_27) { + return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_27.as_canonical_u64() }); + } + if (__v_60 != __v_28) { + return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_28.as_canonical_u64() }); + } + if (__v_61 != __v_29) { + return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_29.as_canonical_u64() }); + } + if (__v_62 != __v_30) { + return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_30.as_canonical_u64() }); + } + if (__v_63 != __v_31) { + return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_31.as_canonical_u64() }); + } + if (__v_64 != __v_32) { + return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_32.as_canonical_u64() }); + } + let __ret: [G; OUT_19] = []; + record.function_queries[19].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_20: usize = 1; +const IN_20: usize = 1; +const OUT_20: usize = 1; +fn aiur_fn_20( + inp: [G; IN_20], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_20], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_18] = { let __args: [G; IN_18] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[18].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_18] = unsafe { *(result.output.as_ptr() as *const [G; OUT_18]) }; __ret } else { aiur_fn_18(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_11: G = __r_arr[10]; + let __v_12: G = __r_arr[11]; + let __v_13: G = __r_arr[12]; + let __v_14: G = __r_arr[13]; + let __v_15: G = __r_arr[14]; + let __v_16: G = __r_arr[15]; + let __v_17: G = __r_arr[16]; + let __v_18: G = __r_arr[17]; + let __v_19: G = __r_arr[18]; + let __v_20: G = __r_arr[19]; + let __v_21: G = __r_arr[20]; + let __v_22: G = __r_arr[21]; + let __v_23: G = __r_arr[22]; + let __v_24: G = __r_arr[23]; + let __v_25: G = __r_arr[24]; + let __v_26: G = __r_arr[25]; + let __v_27: G = __r_arr[26]; + let __v_28: G = __r_arr[27]; + let __v_29: G = __r_arr[28]; + let __v_30: G = __r_arr[29]; + let __v_31: G = __r_arr[30]; + let __v_32: G = __r_arr[31]; + let __v_33: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_20] = [__v_33]; + record.function_queries[20].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_21: usize = 67; +const IN_21: usize = 67; +const OUT_21: usize = 67; +fn aiur_fn_21( + inp: [G; IN_21], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_21], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + let __v_51: G = inp[51]; + let __v_52: G = inp[52]; + let __v_53: G = inp[53]; + let __v_54: G = inp[54]; + let __v_55: G = inp[55]; + let __v_56: G = inp[56]; + let __v_57: G = inp[57]; + let __v_58: G = inp[58]; + let __v_59: G = inp[59]; + let __v_60: G = inp[60]; + let __v_61: G = inp[61]; + let __v_62: G = inp[62]; + let __v_63: G = inp[63]; + let __v_64: G = inp[64]; + let __v_65: G = inp[65]; + let __v_66: G = inp[66]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __v_67: G = G::from_u64(1); + let __v_68: G = G::from_u64(1); + let __v_69: G = G::from_u64(1); + let __ret: [G; OUT_21] = [__v_67, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_68, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69, __v_69]; + record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; 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: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __v_67: G = __loaded[0]; + let __v_68: G = __loaded[1]; + let __v_69: G = __loaded[2]; + let __v_70: G = __loaded[3]; + let __v_71: G = __loaded[4]; + let __v_72: G = __loaded[5]; + let __v_73: G = __loaded[6]; + let __v_74: G = __loaded[7]; + let __v_75: G = __loaded[8]; + let __v_76: G = __loaded[9]; + let __v_77: G = __loaded[10]; + let __v_78: G = __loaded[11]; + let __v_79: G = __loaded[12]; + let __v_80: G = __loaded[13]; + let __v_81: G = __loaded[14]; + let __v_82: G = __loaded[15]; + let __v_83: G = __loaded[16]; + let __v_84: G = __loaded[17]; + let __v_85: G = __loaded[18]; + let __v_86: G = __loaded[19]; + let __v_87: G = __loaded[20]; + let __v_88: G = __loaded[21]; + let __v_89: G = __loaded[22]; + let __v_90: G = __loaded[23]; + let __v_91: G = __loaded[24]; + let __v_92: G = __loaded[25]; + let __v_93: G = __loaded[26]; + let __v_94: G = __loaded[27]; + let __v_95: G = __loaded[28]; + let __v_96: G = __loaded[29]; + let __v_97: G = __loaded[30]; + let __v_98: G = __loaded[31]; + let __v_99: G = __loaded[32]; + let __v_100: G = __loaded[33]; + let __v_101: G = G::from_u64(0); + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__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_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_101]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __v_102: G = __r_arr[0]; + let __v_103: G = __r_arr[1]; + let __v_104: G = __r_arr[2]; + let __v_105: G = __r_arr[3]; + let __v_106: G = __r_arr[4]; + let __v_107: G = __r_arr[5]; + let __v_108: G = __r_arr[6]; + let __v_109: G = __r_arr[7]; + let __v_110: G = __r_arr[8]; + let __v_111: G = __r_arr[9]; + let __v_112: G = __r_arr[10]; + let __v_113: G = __r_arr[11]; + let __v_114: G = __r_arr[12]; + let __v_115: G = __r_arr[13]; + let __v_116: G = __r_arr[14]; + let __v_117: G = __r_arr[15]; + let __v_118: G = __r_arr[16]; + let __v_119: G = __r_arr[17]; + let __v_120: G = __r_arr[18]; + let __v_121: G = __r_arr[19]; + let __v_122: G = __r_arr[20]; + let __v_123: G = __r_arr[21]; + let __v_124: G = __r_arr[22]; + let __v_125: G = __r_arr[23]; + let __v_126: G = __r_arr[24]; + let __v_127: G = __r_arr[25]; + let __v_128: G = __r_arr[26]; + let __v_129: G = __r_arr[27]; + let __v_130: G = __r_arr[28]; + let __v_131: G = __r_arr[29]; + let __v_132: G = __r_arr[30]; + let __v_133: G = __r_arr[31]; + let __v_134: G = __r_arr[32]; + let __v_135: G = __r_arr[33]; + let __v_136: G = __r_arr[34]; + let __v_137: G = __r_arr[35]; + let __v_138: G = __r_arr[36]; + let __v_139: G = __r_arr[37]; + let __v_140: G = __r_arr[38]; + let __v_141: G = __r_arr[39]; + let __v_142: G = __r_arr[40]; + let __v_143: G = __r_arr[41]; + let __v_144: G = __r_arr[42]; + let __v_145: G = __r_arr[43]; + let __v_146: G = __r_arr[44]; + let __v_147: G = __r_arr[45]; + let __v_148: G = __r_arr[46]; + let __v_149: G = __r_arr[47]; + let __v_150: G = __r_arr[48]; + let __v_151: G = __r_arr[49]; + let __v_152: G = __r_arr[50]; + let __v_153: G = __r_arr[51]; + let __v_154: G = __r_arr[52]; + let __v_155: G = __r_arr[53]; + let __v_156: G = __r_arr[54]; + let __v_157: G = __r_arr[55]; + let __v_158: G = __r_arr[56]; + let __v_159: G = __r_arr[57]; + let __v_160: G = __r_arr[58]; + let __v_161: G = __r_arr[59]; + let __v_162: G = __r_arr[60]; + let __v_163: G = __r_arr[61]; + let __v_164: G = __r_arr[62]; + let __v_165: G = __r_arr[63]; + let __v_166: G = __r_arr[64]; + let __v_167: G = __r_arr[65]; + let __v_168: G = __r_arr[66]; + match __v_102.as_canonical_u64() { + 0u64 => { + let __v_169: G = G::from_u64(1); + let __ret: [G; OUT_21] = [__v_169, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; + record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_169: G = G::from_u64(4); + let __v_170: G = G::from_u64(8); + let __v_171: G = G::from_u64(103); + let __v_172: G = G::from_u64(230); + let __v_173: G = G::from_u64(9); + let __v_174: G = G::from_u64(106); + let __v_175: G = G::from_u64(133); + let __v_176: G = G::from_u64(174); + let __v_177: G = G::from_u64(103); + let __v_178: G = G::from_u64(187); + let __v_179: G = G::from_u64(114); + let __v_180: G = G::from_u64(243); + let __v_181: G = G::from_u64(110); + let __v_182: G = G::from_u64(60); + let __v_183: G = G::from_u64(58); + let __v_184: G = G::from_u64(245); + let __v_185: G = G::from_u64(79); + let __v_186: G = G::from_u64(165); + let __v_187: G = G::from_u64(127); + let __v_188: G = G::from_u64(82); + let __v_189: G = G::from_u64(14); + let __v_190: G = G::from_u64(81); + let __v_191: G = G::from_u64(140); + let __v_192: G = G::from_u64(104); + let __v_193: G = G::from_u64(5); + let __v_194: G = G::from_u64(155); + let __v_195: G = G::from_u64(171); + let __v_196: G = G::from_u64(217); + let __v_197: G = G::from_u64(131); + let __v_198: G = G::from_u64(31); + let __v_199: G = G::from_u64(25); + let __v_200: G = G::from_u64(205); + let __v_201: G = G::from_u64(224); + let __v_202: G = G::from_u64(91); + match __v_135.as_canonical_u64() { + 1u64 => { + let __v_203: G = (__v_170 * __v_66); + let __v_204: G = (__v_169 + __v_203); + let __v_205: G = G::from_u64(0); + let __v_206: G = G::from_u64(0); + let __v_207: G = G::from_u64(0); + let __v_208: G = G::from_u64(0); + let __v_209: G = G::from_u64(0); + let __v_210: G = G::from_u64(0); + let __v_211: G = G::from_u64(0); + let __v_212: G = G::from_u64(0); + let __v_213: G = G::from_u64(64); + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __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_130, __v_131, __v_132, __v_133, __v_134, __v_34, __v_35, __v_36, __v_37, __v_38, __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_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213, __v_204]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __v_214: G = __r_arr[0]; + let __v_215: G = __r_arr[1]; + let __v_216: G = __r_arr[2]; + let __v_217: G = __r_arr[3]; + let __v_218: G = __r_arr[4]; + let __v_219: G = __r_arr[5]; + let __v_220: G = __r_arr[6]; + let __v_221: G = __r_arr[7]; + let __v_222: G = __r_arr[8]; + let __v_223: G = __r_arr[9]; + let __v_224: G = __r_arr[10]; + let __v_225: G = __r_arr[11]; + let __v_226: G = __r_arr[12]; + let __v_227: G = __r_arr[13]; + let __v_228: G = __r_arr[14]; + let __v_229: G = __r_arr[15]; + let __v_230: G = __r_arr[16]; + let __v_231: G = __r_arr[17]; + let __v_232: G = __r_arr[18]; + let __v_233: G = __r_arr[19]; + let __v_234: G = __r_arr[20]; + let __v_235: G = __r_arr[21]; + let __v_236: G = __r_arr[22]; + let __v_237: G = __r_arr[23]; + let __v_238: G = __r_arr[24]; + let __v_239: G = __r_arr[25]; + let __v_240: G = __r_arr[26]; + let __v_241: G = __r_arr[27]; + let __v_242: G = __r_arr[28]; + let __v_243: G = __r_arr[29]; + let __v_244: G = __r_arr[30]; + let __v_245: G = __r_arr[31]; + let __v_246: G = G::from_u64(0); + let __v_247: G = G::from_u64(0); + let __v_248: G = G::from_u64(0); + let __v_249: G = { let __values: [G; 34] = [__v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_21] = [__v_246, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_247, __v_248, __v_249, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245]; + record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_203: G = G::from_u64(0); + let __v_204: G = G::from_u64(0); + let __v_205: G = G::from_u64(0); + let __v_206: G = G::from_u64(0); + let __v_207: G = G::from_u64(0); + let __v_208: G = G::from_u64(0); + let __v_209: G = G::from_u64(0); + let __v_210: G = G::from_u64(0); + let __v_211: G = G::from_u64(64); + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __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_130, __v_131, __v_132, __v_133, __v_134, __v_34, __v_35, __v_36, __v_37, __v_38, __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_203, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_169]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __v_212: G = __r_arr[0]; + let __v_213: G = __r_arr[1]; + let __v_214: G = __r_arr[2]; + let __v_215: G = __r_arr[3]; + let __v_216: G = __r_arr[4]; + let __v_217: G = __r_arr[5]; + let __v_218: G = __r_arr[6]; + let __v_219: G = __r_arr[7]; + let __v_220: G = __r_arr[8]; + let __v_221: G = __r_arr[9]; + let __v_222: G = __r_arr[10]; + let __v_223: G = __r_arr[11]; + let __v_224: G = __r_arr[12]; + let __v_225: G = __r_arr[13]; + let __v_226: G = __r_arr[14]; + let __v_227: G = __r_arr[15]; + let __v_228: G = __r_arr[16]; + let __v_229: G = __r_arr[17]; + let __v_230: G = __r_arr[18]; + let __v_231: G = __r_arr[19]; + let __v_232: G = __r_arr[20]; + let __v_233: G = __r_arr[21]; + let __v_234: G = __r_arr[22]; + let __v_235: G = __r_arr[23]; + let __v_236: G = __r_arr[24]; + let __v_237: G = __r_arr[25]; + let __v_238: G = __r_arr[26]; + let __v_239: G = __r_arr[27]; + let __v_240: G = __r_arr[28]; + let __v_241: G = __r_arr[29]; + let __v_242: G = __r_arr[30]; + let __v_243: G = __r_arr[31]; + let __v_244: G = G::from_u64(0); + let __v_245: G = G::from_u64(0); + let __v_246: G = G::from_u64(0); + let __v_247: G = { let __values: [G; 34] = [__v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_21] = [__v_244, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_245, __v_246, __v_247, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225, __v_226, __v_227, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243]; + record.function_queries[21].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_102.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_22: usize = 34; +const IN_22: usize = 34; +const OUT_22: usize = 32; +fn aiur_fn_22( + inp: [G; IN_22], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_22], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; let __ptr_u64 = __v_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: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __v_34: G = __loaded[0]; + let __v_35: G = __loaded[1]; + let __v_36: G = __loaded[2]; + let __v_37: G = __loaded[3]; + let __v_38: G = __loaded[4]; + let __v_39: G = __loaded[5]; + let __v_40: G = __loaded[6]; + let __v_41: G = __loaded[7]; + let __v_42: G = __loaded[8]; + let __v_43: G = __loaded[9]; + let __v_44: G = __loaded[10]; + let __v_45: G = __loaded[11]; + let __v_46: G = __loaded[12]; + let __v_47: G = __loaded[13]; + let __v_48: G = __loaded[14]; + let __v_49: G = __loaded[15]; + let __v_50: G = __loaded[16]; + let __v_51: G = __loaded[17]; + let __v_52: G = __loaded[18]; + let __v_53: G = __loaded[19]; + let __v_54: G = __loaded[20]; + let __v_55: G = __loaded[21]; + let __v_56: G = __loaded[22]; + let __v_57: G = __loaded[23]; + let __v_58: G = __loaded[24]; + let __v_59: G = __loaded[25]; + let __v_60: G = __loaded[26]; + let __v_61: G = __loaded[27]; + let __v_62: G = __loaded[28]; + let __v_63: G = __loaded[29]; + let __v_64: G = __loaded[30]; + let __v_65: G = __loaded[31]; + let __v_66: G = __loaded[32]; + let __v_67: G = __loaded[33]; + match __v_34.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_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]; + record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 34] = { let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; 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: 34 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 34] = __args[..34].try_into().unwrap(); __arr }; + let __v_68: G = __loaded[0]; + let __v_69: G = __loaded[1]; + let __v_70: G = __loaded[2]; + let __v_71: G = __loaded[3]; + let __v_72: G = __loaded[4]; + let __v_73: G = __loaded[5]; + let __v_74: G = __loaded[6]; + let __v_75: G = __loaded[7]; + let __v_76: G = __loaded[8]; + let __v_77: G = __loaded[9]; + let __v_78: G = __loaded[10]; + let __v_79: G = __loaded[11]; + let __v_80: G = __loaded[12]; + let __v_81: G = __loaded[13]; + let __v_82: G = __loaded[14]; + let __v_83: G = __loaded[15]; + let __v_84: G = __loaded[16]; + let __v_85: G = __loaded[17]; + let __v_86: G = __loaded[18]; + let __v_87: G = __loaded[19]; + let __v_88: G = __loaded[20]; + let __v_89: G = __loaded[21]; + let __v_90: G = __loaded[22]; + let __v_91: G = __loaded[23]; + let __v_92: G = __loaded[24]; + let __v_93: G = __loaded[25]; + let __v_94: G = __loaded[26]; + let __v_95: G = __loaded[27]; + let __v_96: G = __loaded[28]; + let __v_97: G = __loaded[29]; + let __v_98: G = __loaded[30]; + let __v_99: G = __loaded[31]; + let __v_100: G = __loaded[32]; + let __v_101: G = __loaded[33]; + let __v_102: G = G::from_u64(1); + let __r_arr: [G; OUT_21] = { let __args: [G; IN_21] = [__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_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_102]; let __cu = unconstrained; if let Some(result) = record.function_queries[21].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_21] = unsafe { *(result.output.as_ptr() as *const [G; OUT_21]) }; __ret } else { aiur_fn_21(__args, record, io_buffer, __cu)? } }; + let __v_103: G = __r_arr[0]; + let __v_104: G = __r_arr[1]; + let __v_105: G = __r_arr[2]; + let __v_106: G = __r_arr[3]; + let __v_107: G = __r_arr[4]; + let __v_108: G = __r_arr[5]; + let __v_109: G = __r_arr[6]; + let __v_110: G = __r_arr[7]; + let __v_111: G = __r_arr[8]; + let __v_112: G = __r_arr[9]; + let __v_113: G = __r_arr[10]; + let __v_114: G = __r_arr[11]; + let __v_115: G = __r_arr[12]; + let __v_116: G = __r_arr[13]; + let __v_117: G = __r_arr[14]; + let __v_118: G = __r_arr[15]; + let __v_119: G = __r_arr[16]; + let __v_120: G = __r_arr[17]; + let __v_121: G = __r_arr[18]; + let __v_122: G = __r_arr[19]; + let __v_123: G = __r_arr[20]; + let __v_124: G = __r_arr[21]; + let __v_125: G = __r_arr[22]; + let __v_126: G = __r_arr[23]; + let __v_127: G = __r_arr[24]; + let __v_128: G = __r_arr[25]; + let __v_129: G = __r_arr[26]; + let __v_130: G = __r_arr[27]; + let __v_131: G = __r_arr[28]; + let __v_132: G = __r_arr[29]; + let __v_133: G = __r_arr[30]; + let __v_134: G = __r_arr[31]; + let __v_135: G = __r_arr[32]; + let __v_136: G = __r_arr[33]; + let __v_137: G = __r_arr[34]; + let __v_138: G = __r_arr[35]; + let __v_139: G = __r_arr[36]; + let __v_140: G = __r_arr[37]; + let __v_141: G = __r_arr[38]; + let __v_142: G = __r_arr[39]; + let __v_143: G = __r_arr[40]; + let __v_144: G = __r_arr[41]; + let __v_145: G = __r_arr[42]; + let __v_146: G = __r_arr[43]; + let __v_147: G = __r_arr[44]; + let __v_148: G = __r_arr[45]; + let __v_149: G = __r_arr[46]; + let __v_150: G = __r_arr[47]; + let __v_151: G = __r_arr[48]; + let __v_152: G = __r_arr[49]; + let __v_153: G = __r_arr[50]; + let __v_154: G = __r_arr[51]; + let __v_155: G = __r_arr[52]; + let __v_156: G = __r_arr[53]; + let __v_157: G = __r_arr[54]; + let __v_158: G = __r_arr[55]; + let __v_159: G = __r_arr[56]; + let __v_160: G = __r_arr[57]; + let __v_161: G = __r_arr[58]; + let __v_162: G = __r_arr[59]; + let __v_163: G = __r_arr[60]; + let __v_164: G = __r_arr[61]; + let __v_165: G = __r_arr[62]; + let __v_166: G = __r_arr[63]; + let __v_167: G = __r_arr[64]; + let __v_168: G = __r_arr[65]; + let __v_169: G = __r_arr[66]; + match __v_103.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { 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_170: G = __r_arr[0]; + let __v_171: G = __r_arr[1]; + let __v_172: G = __r_arr[2]; + let __v_173: G = __r_arr[3]; + let __v_174: G = __r_arr[4]; + let __v_175: G = __r_arr[5]; + let __v_176: G = __r_arr[6]; + let __v_177: G = __r_arr[7]; + let __v_178: G = __r_arr[8]; + let __v_179: G = __r_arr[9]; + let __v_180: G = __r_arr[10]; + let __v_181: G = __r_arr[11]; + let __v_182: G = __r_arr[12]; + let __v_183: G = __r_arr[13]; + let __v_184: G = __r_arr[14]; + let __v_185: G = __r_arr[15]; + let __v_186: G = __r_arr[16]; + let __v_187: G = __r_arr[17]; + let __v_188: G = __r_arr[18]; + let __v_189: G = __r_arr[19]; + let __v_190: G = __r_arr[20]; + let __v_191: G = __r_arr[21]; + let __v_192: G = __r_arr[22]; + let __v_193: G = __r_arr[23]; + let __v_194: G = __r_arr[24]; + let __v_195: G = __r_arr[25]; + let __v_196: G = __r_arr[26]; + let __v_197: G = __r_arr[27]; + let __v_198: G = __r_arr[28]; + let __v_199: G = __r_arr[29]; + let __v_200: G = __r_arr[30]; + let __v_201: G = __r_arr[31]; + let __ret: [G; OUT_22] = [__v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201]; + record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_170: G = G::from_u64(0); + let __v_171: G = { let __values: [G; 34] = [__v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_22] = { let __args: [G; IN_22] = [__v_170, __v_171, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135]; let __cu = unconstrained; if let Some(result) = record.function_queries[22].get_mut(&__args[..]) { 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_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 = __r_arr[18]; + let __v_191: G = __r_arr[19]; + let __v_192: G = __r_arr[20]; + let __v_193: G = __r_arr[21]; + let __v_194: G = __r_arr[22]; + let __v_195: G = __r_arr[23]; + let __v_196: G = __r_arr[24]; + let __v_197: G = __r_arr[25]; + let __v_198: G = __r_arr[26]; + let __v_199: G = __r_arr[27]; + let __v_200: G = __r_arr[28]; + let __v_201: G = __r_arr[29]; + let __v_202: G = __r_arr[30]; + let __v_203: G = __r_arr[31]; + let __ret: [G; OUT_22] = [__v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193, __v_194, __v_195, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201, __v_202, __v_203]; + record.function_queries[22].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_23: usize = 7; +const IN_23: usize = 7; +const OUT_23: usize = 1; +fn aiur_fn_23( + inp: [G; IN_23], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_23], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_26] = { let __args: [G; IN_26] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[26].get_mut(&__args[..]) { 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_10: G = __r_arr[0]; + let __ret: [G; OUT_23] = [__v_10]; + record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_8, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *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_27] = { let __args: [G; IN_27] = [__v_9, __v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[27].get_mut(&__args[..]) { 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_12: G = __r_arr[0]; + let __ret: [G; OUT_23] = [__v_12]; + record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(1); + 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_23] = { let __args: [G; IN_23] = [__v_9, __v_11, __v_13, __v_15, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_23] = [__v_16]; + record.function_queries[23].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_24: usize = 1; +const IN_24: usize = 1; +const OUT_24: usize = 64; +fn aiur_fn_24( + inp: [G; IN_24], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_24], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + match __v_13.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + match __v_16.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + match __v_19.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_22: G = __loaded[0]; + let __v_23: G = __loaded[1]; + let __v_24: G = __loaded[2]; + match __v_22.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_25: G = __loaded[0]; + let __v_26: G = __loaded[1]; + let __v_27: G = __loaded[2]; + match __v_25.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_28: G = __loaded[0]; + let __v_29: G = __loaded[1]; + let __v_30: G = __loaded[2]; + match __v_28.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_30.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_31: G = __loaded[0]; + let __v_32: G = __loaded[1]; + let __v_33: G = __loaded[2]; + match __v_31.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_34: G = __loaded[0]; + let __v_35: G = __loaded[1]; + let __v_36: G = __loaded[2]; + match __v_34.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_36.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_37: G = __loaded[0]; + let __v_38: G = __loaded[1]; + let __v_39: G = __loaded[2]; + match __v_37.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_39.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_40: G = __loaded[0]; + let __v_41: G = __loaded[1]; + let __v_42: G = __loaded[2]; + match __v_40.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_43: G = __loaded[0]; + let __v_44: G = __loaded[1]; + let __v_45: G = __loaded[2]; + match __v_43.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_45.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_46: G = __loaded[0]; + let __v_47: G = __loaded[1]; + let __v_48: G = __loaded[2]; + match __v_46.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_49: G = __loaded[0]; + let __v_50: G = __loaded[1]; + let __v_51: G = __loaded[2]; + match __v_49.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_51.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_52: G = __loaded[0]; + let __v_53: G = __loaded[1]; + let __v_54: G = __loaded[2]; + match __v_52.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_54.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_55: G = __loaded[0]; + let __v_56: G = __loaded[1]; + let __v_57: G = __loaded[2]; + match __v_55.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_57.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_58: G = __loaded[0]; + let __v_59: G = __loaded[1]; + let __v_60: G = __loaded[2]; + match __v_58.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_60.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_61: G = __loaded[0]; + let __v_62: G = __loaded[1]; + let __v_63: G = __loaded[2]; + match __v_61.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_63.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_64: G = __loaded[0]; + let __v_65: G = __loaded[1]; + let __v_66: G = __loaded[2]; + match __v_64.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_66.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_67: G = __loaded[0]; + let __v_68: G = __loaded[1]; + let __v_69: G = __loaded[2]; + match __v_67.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_69.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_70: G = __loaded[0]; + let __v_71: G = __loaded[1]; + let __v_72: G = __loaded[2]; + match __v_70.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_72.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_73: G = __loaded[0]; + let __v_74: G = __loaded[1]; + let __v_75: G = __loaded[2]; + match __v_73.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_75.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_76: G = __loaded[0]; + let __v_77: G = __loaded[1]; + let __v_78: G = __loaded[2]; + match __v_76.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_78.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_79: G = __loaded[0]; + let __v_80: G = __loaded[1]; + let __v_81: G = __loaded[2]; + match __v_79.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_81.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_82: G = __loaded[0]; + let __v_83: G = __loaded[1]; + let __v_84: G = __loaded[2]; + match __v_82.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_84.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_85: G = __loaded[0]; + let __v_86: G = __loaded[1]; + let __v_87: G = __loaded[2]; + match __v_85.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_87.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_88: G = __loaded[0]; + let __v_89: G = __loaded[1]; + let __v_90: G = __loaded[2]; + match __v_88.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_90.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_91: G = __loaded[0]; + let __v_92: G = __loaded[1]; + let __v_93: G = __loaded[2]; + match __v_91.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_94: G = __loaded[0]; + let __v_95: G = __loaded[1]; + let __v_96: G = __loaded[2]; + match __v_94.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_96.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_97: G = __loaded[0]; + let __v_98: G = __loaded[1]; + let __v_99: G = __loaded[2]; + match __v_97.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_99.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_100: G = __loaded[0]; + let __v_101: G = __loaded[1]; + let __v_102: G = __loaded[2]; + match __v_100.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_102.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_104: G = __loaded[1]; + let __v_105: G = __loaded[2]; + match __v_103.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_105.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_106: G = __loaded[0]; + let __v_107: G = __loaded[1]; + let __v_108: G = __loaded[2]; + match __v_106.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_108.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_109: G = __loaded[0]; + let __v_110: G = __loaded[1]; + let __v_111: G = __loaded[2]; + match __v_109.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_111.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_112: G = __loaded[0]; + let __v_113: G = __loaded[1]; + let __v_114: G = __loaded[2]; + match __v_112.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_114.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_115: G = __loaded[0]; + let __v_116: G = __loaded[1]; + let __v_117: G = __loaded[2]; + match __v_115.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_117.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_118: G = __loaded[0]; + let __v_119: G = __loaded[1]; + let __v_120: G = __loaded[2]; + match __v_118.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_120.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_121: G = __loaded[0]; + let __v_122: G = __loaded[1]; + let __v_123: G = __loaded[2]; + match __v_121.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_123.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_124: G = __loaded[0]; + let __v_125: G = __loaded[1]; + let __v_126: G = __loaded[2]; + match __v_124.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_126.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_127: G = __loaded[0]; + let __v_128: G = __loaded[1]; + let __v_129: G = __loaded[2]; + match __v_127.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_129.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_130: G = __loaded[0]; + let __v_131: G = __loaded[1]; + let __v_132: G = __loaded[2]; + match __v_130.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_132.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_133: G = __loaded[0]; + let __v_134: G = __loaded[1]; + let __v_135: G = __loaded[2]; + match __v_133.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_135.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_136: G = __loaded[0]; + let __v_137: G = __loaded[1]; + let __v_138: G = __loaded[2]; + match __v_136.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_138.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_139: G = __loaded[0]; + let __v_140: G = __loaded[1]; + let __v_141: G = __loaded[2]; + match __v_139.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_141.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_142: G = __loaded[0]; + let __v_143: G = __loaded[1]; + let __v_144: G = __loaded[2]; + match __v_142.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_144.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_145: G = __loaded[0]; + let __v_146: G = __loaded[1]; + let __v_147: G = __loaded[2]; + match __v_145.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_147.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_148: G = __loaded[0]; + let __v_149: G = __loaded[1]; + let __v_150: G = __loaded[2]; + match __v_148.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_150.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_151: G = __loaded[0]; + let __v_152: G = __loaded[1]; + let __v_153: G = __loaded[2]; + match __v_151.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_153.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_154: G = __loaded[0]; + let __v_155: G = __loaded[1]; + let __v_156: G = __loaded[2]; + match __v_154.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_156.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_157: G = __loaded[0]; + let __v_158: G = __loaded[1]; + let __v_159: G = __loaded[2]; + match __v_157.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_159.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_160: G = __loaded[0]; + let __v_161: G = __loaded[1]; + let __v_162: G = __loaded[2]; + match __v_160.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_162.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_163: G = __loaded[0]; + let __v_164: G = __loaded[1]; + let __v_165: G = __loaded[2]; + match __v_163.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_165.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_166: G = __loaded[0]; + let __v_167: G = __loaded[1]; + let __v_168: G = __loaded[2]; + match __v_166.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_168.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_169: G = __loaded[0]; + let __v_170: G = __loaded[1]; + let __v_171: G = __loaded[2]; + match __v_169.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_171.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_172: G = __loaded[0]; + let __v_173: G = __loaded[1]; + let __v_174: G = __loaded[2]; + match __v_172.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_174.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_175: G = __loaded[0]; + let __v_176: G = __loaded[1]; + let __v_177: G = __loaded[2]; + match __v_175.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_177.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_178: G = __loaded[0]; + let __v_179: G = __loaded[1]; + let __v_180: G = __loaded[2]; + match __v_178.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_180.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_181: G = __loaded[0]; + let __v_182: G = __loaded[1]; + let __v_183: G = __loaded[2]; + match __v_181.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_183.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_184: G = __loaded[0]; + let __v_185: G = __loaded[1]; + let __v_186: G = __loaded[2]; + match __v_184.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_186.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_187: G = __loaded[0]; + let __v_188: G = __loaded[1]; + let __v_189: G = __loaded[2]; + match __v_187.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_189.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_190: G = __loaded[0]; + let __v_191: G = __loaded[1]; + let __v_192: G = __loaded[2]; + match __v_190.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_24] = [__v_191, __v_188, __v_185, __v_182, __v_179, __v_176, __v_173, __v_170, __v_167, __v_164, __v_161, __v_158, __v_155, __v_152, __v_149, __v_146, __v_143, __v_140, __v_137, __v_134, __v_131, __v_128, __v_125, __v_122, __v_119, __v_116, __v_113, __v_110, __v_107, __v_104, __v_101, __v_98, __v_95, __v_92, __v_89, __v_86, __v_83, __v_80, __v_77, __v_74, __v_71, __v_68, __v_65, __v_62, __v_59, __v_56, __v_53, __v_50, __v_47, __v_44, __v_41, __v_38, __v_35, __v_32, __v_29, __v_26, __v_23, __v_20, __v_17, __v_14, __v_11, __v_8, __v_5, __v_2]; + record.function_queries[24].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_190.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_187.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_184.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_181.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_178.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_175.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_172.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_169.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_166.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_163.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_160.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_157.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_154.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_151.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_148.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_145.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_142.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_139.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_136.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_133.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_130.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_127.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_124.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_121.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_118.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_115.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_112.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_109.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_106.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_103.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_100.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_97.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_94.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_91.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_88.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_85.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_82.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_79.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_76.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_73.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_70.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_67.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_64.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_46.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_43.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_37.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_25: usize = 2; +const IN_25: usize = 2; +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_25], 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_25] = [__v_0]; + record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_25] = { let __args: [G; IN_25] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_25] = [__v_7]; + record.function_queries[25].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_26: usize = 6; +const IN_26: usize = 6; +const OUT_26: usize = 1; +fn aiur_fn_26( + inp: [G; IN_26], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_26], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(2); + let __v_8: G = G::from_u64(8); + match __v_1.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + match __v_9.as_canonical_u64() { + 0u64 => { + match __v_10.as_canonical_u64() { + 0u64 => { + match __v_11.as_canonical_u64() { + 0u64 => { + match __v_12.as_canonical_u64() { + 0u64 => { + match __v_13.as_canonical_u64() { + 0u64 => { + match __v_14.as_canonical_u64() { + 0u64 => { + match __v_15.as_canonical_u64() { + 0u64 => { + match __v_16.as_canonical_u64() { + 0u64 => { + let __v_17: G = (__v_6 + __v_7); + let __v_18: G = (__v_8 + __v_17); + let __v_19: G = G::from_u64(0); + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + let __v_26: G = __loaded[6]; + let __v_27: G = __loaded[7]; + let __v_28: G = __loaded[8]; + let __v_29: G = __loaded[9]; + let __v_30: G = __loaded[10]; + let __v_31: G = __loaded[11]; + let __v_32: G = __loaded[12]; + let __v_33: G = __loaded[13]; + let __v_34: G = __loaded[14]; + let __v_35: G = __loaded[15]; + let __v_36: G = __loaded[16]; + let __v_37: G = __loaded[17]; + let __v_38: G = __loaded[18]; + let __v_39: G = __loaded[19]; + let __v_40: G = __loaded[20]; + let __v_41: G = __loaded[21]; + let __v_42: G = __loaded[22]; + let __v_43: G = __loaded[23]; + let __v_44: G = __loaded[24]; + let __v_45: G = __loaded[25]; + let __v_46: G = __loaded[26]; + let __v_47: G = __loaded[27]; + let __v_48: G = __loaded[28]; + let __v_49: G = __loaded[29]; + let __v_50: G = __loaded[30]; + let __v_51: G = __loaded[31]; + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = G::from_u64(0); + let __v_78: G = G::from_u64(0); + let __v_79: G = G::from_u64(0); + let __v_80: G = G::from_u64(0); + let __v_81: G = G::from_u64(0); + let __v_82: G = G::from_u64(0); + let __v_83: G = G::from_u64(0); + let __v_84: G = G::from_u64(0); + let __v_85: G = G::from_u64(0); + let __v_86: G = G::from_u64(0); + let __v_87: G = G::from_u64(0); + let __v_88: G = G::from_u64(0); + let __v_89: G = G::from_u64(0); + 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 __v_93: G = G::from_u64(0); + let __v_94: G = G::from_u64(0); + let __v_95: G = G::from_u64(0); + let __v_96: G = G::from_u64(0); + let __v_97: G = G::from_u64(0); + let __v_98: G = G::from_u64(0); + let __v_99: G = G::from_u64(0); + let __v_100: G = G::from_u64(0); + let __v_101: G = G::from_u64(0); + let __v_102: G = G::from_u64(0); + let __v_103: G = G::from_u64(0); + let __v_104: G = G::from_u64(0); + let __v_105: G = G::from_u64(0); + let __v_106: G = G::from_u64(0); + 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_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 __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_116: G = __loaded[0]; + let __v_117: G = __loaded[1]; + let __v_118: G = __loaded[2]; + let __v_119: G = __loaded[3]; + let __v_120: G = __loaded[4]; + let __v_121: G = __loaded[5]; + let __v_122: G = __loaded[6]; + let __v_123: G = __loaded[7]; + let __v_124: G = G::from_u64(0); + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __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_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __v_125: G = __r_arr[0]; + let __v_126: G = __r_arr[1]; + let __v_127: G = __r_arr[2]; + let __v_128: G = __r_arr[3]; + let __v_129: G = __r_arr[4]; + let __v_130: G = __r_arr[5]; + let __v_131: G = __r_arr[6]; + let __v_132: G = __r_arr[7]; + let __v_133: G = __r_arr[8]; + let __v_134: G = __r_arr[9]; + let __v_135: G = __r_arr[10]; + let __v_136: G = __r_arr[11]; + let __v_137: G = __r_arr[12]; + let __v_138: G = __r_arr[13]; + let __v_139: G = __r_arr[14]; + let __v_140: G = __r_arr[15]; + let __v_141: G = __r_arr[16]; + let __v_142: G = __r_arr[17]; + let __v_143: G = __r_arr[18]; + let __v_144: G = __r_arr[19]; + let __v_145: G = __r_arr[20]; + let __v_146: G = __r_arr[21]; + let __v_147: G = __r_arr[22]; + let __v_148: G = __r_arr[23]; + let __v_149: G = __r_arr[24]; + let __v_150: G = __r_arr[25]; + let __v_151: G = __r_arr[26]; + let __v_152: G = __r_arr[27]; + let __v_153: G = __r_arr[28]; + let __v_154: G = __r_arr[29]; + let __v_155: G = __r_arr[30]; + let __v_156: G = __r_arr[31]; + let __v_157: G = { let __values: [G; 34] = [__v_19, __v_5, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_26] = [__v_157]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_26] = [__v_5]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_9: G = G::from_u64(0); + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_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]; + let __v_20: G = __loaded[10]; + let __v_21: G = __loaded[11]; + let __v_22: G = __loaded[12]; + let __v_23: G = __loaded[13]; + let __v_24: G = __loaded[14]; + let __v_25: G = __loaded[15]; + let __v_26: G = __loaded[16]; + let __v_27: G = __loaded[17]; + let __v_28: G = __loaded[18]; + let __v_29: G = __loaded[19]; + let __v_30: G = __loaded[20]; + let __v_31: G = __loaded[21]; + let __v_32: G = __loaded[22]; + let __v_33: G = __loaded[23]; + let __v_34: G = __loaded[24]; + let __v_35: G = __loaded[25]; + let __v_36: G = __loaded[26]; + let __v_37: G = __loaded[27]; + let __v_38: G = __loaded[28]; + let __v_39: G = __loaded[29]; + let __v_40: G = __loaded[30]; + let __v_41: G = __loaded[31]; + let __v_42: G = { let __values: [G; 34] = [__v_9, __v_5, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_26] = [__v_42]; + record.function_queries[26].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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); + let __v_20: G = G::from_bool((__v_19 == G::ZERO)); + let __v_21: G = (__v_20 * __v_6); + let __v_22: G = (__v_18 + __v_21); + 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_25] = { let __args: [G; IN_25] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[25].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_25] = unsafe { *(result.output.as_ptr() as *const [G; OUT_25]) }; __ret } else { aiur_fn_25(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { 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_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __v_29: G = __r_arr[2]; + let __v_30: G = __r_arr[3]; + let __v_31: G = __r_arr[4]; + let __v_32: G = __r_arr[5]; + let __v_33: G = __r_arr[6]; + let __v_34: G = __r_arr[7]; + let __v_35: G = __r_arr[8]; + let __v_36: G = __r_arr[9]; + let __v_37: G = __r_arr[10]; + let __v_38: G = __r_arr[11]; + let __v_39: G = __r_arr[12]; + let __v_40: G = __r_arr[13]; + let __v_41: G = __r_arr[14]; + let __v_42: G = __r_arr[15]; + let __v_43: G = __r_arr[16]; + let __v_44: G = __r_arr[17]; + let __v_45: G = __r_arr[18]; + let __v_46: G = __r_arr[19]; + let __v_47: G = __r_arr[20]; + let __v_48: G = __r_arr[21]; + let __v_49: G = __r_arr[22]; + let __v_50: G = __r_arr[23]; + let __v_51: G = __r_arr[24]; + let __v_52: G = __r_arr[25]; + let __v_53: G = __r_arr[26]; + let __v_54: G = __r_arr[27]; + let __v_55: G = __r_arr[28]; + let __v_56: G = __r_arr[29]; + let __v_57: G = __r_arr[30]; + let __v_58: G = __r_arr[31]; + let __v_59: G = __r_arr[32]; + let __v_60: G = __r_arr[33]; + let __v_61: G = __r_arr[34]; + let __v_62: G = __r_arr[35]; + let __v_63: G = __r_arr[36]; + let __v_64: G = __r_arr[37]; + let __v_65: G = __r_arr[38]; + let __v_66: G = __r_arr[39]; + let __v_67: G = __r_arr[40]; + let __v_68: G = __r_arr[41]; + let __v_69: G = __r_arr[42]; + let __v_70: G = __r_arr[43]; + let __v_71: G = __r_arr[44]; + let __v_72: G = __r_arr[45]; + let __v_73: G = __r_arr[46]; + let __v_74: G = __r_arr[47]; + let __v_75: G = __r_arr[48]; + let __v_76: G = __r_arr[49]; + let __v_77: G = __r_arr[50]; + let __v_78: G = __r_arr[51]; + let __v_79: G = __r_arr[52]; + let __v_80: G = __r_arr[53]; + let __v_81: G = __r_arr[54]; + let __v_82: G = __r_arr[55]; + let __v_83: G = __r_arr[56]; + let __v_84: G = __r_arr[57]; + let __v_85: G = __r_arr[58]; + let __v_86: G = __r_arr[59]; + let __v_87: G = __r_arr[60]; + let __v_88: G = __r_arr[61]; + let __v_89: G = __r_arr[62]; + let __v_90: G = __r_arr[63]; + let __v_91: G = G::from_u64(0); + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_92: G = __loaded[0]; + let __v_93: G = __loaded[1]; + let __v_94: G = __loaded[2]; + let __v_95: G = __loaded[3]; + let __v_96: G = __loaded[4]; + let __v_97: G = __loaded[5]; + let __v_98: G = __loaded[6]; + let __v_99: G = __loaded[7]; + let __v_100: G = __loaded[8]; + let __v_101: G = __loaded[9]; + let __v_102: G = __loaded[10]; + let __v_103: G = __loaded[11]; + let __v_104: G = __loaded[12]; + let __v_105: G = __loaded[13]; + let __v_106: G = __loaded[14]; + let __v_107: G = __loaded[15]; + let __v_108: G = __loaded[16]; + let __v_109: G = __loaded[17]; + let __v_110: G = __loaded[18]; + let __v_111: G = __loaded[19]; + let __v_112: G = __loaded[20]; + let __v_113: G = __loaded[21]; + let __v_114: G = __loaded[22]; + let __v_115: G = __loaded[23]; + let __v_116: G = __loaded[24]; + let __v_117: G = __loaded[25]; + let __v_118: G = __loaded[26]; + let __v_119: G = __loaded[27]; + let __v_120: G = __loaded[28]; + let __v_121: G = __loaded[29]; + let __v_122: G = __loaded[30]; + let __v_123: G = __loaded[31]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_124: G = __loaded[0]; + let __v_125: G = __loaded[1]; + let __v_126: G = __loaded[2]; + let __v_127: G = __loaded[3]; + let __v_128: G = __loaded[4]; + let __v_129: G = __loaded[5]; + let __v_130: G = __loaded[6]; + let __v_131: G = __loaded[7]; + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__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_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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_124, __v_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_1, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __v_132: G = __r_arr[0]; + let __v_133: G = __r_arr[1]; + let __v_134: G = __r_arr[2]; + let __v_135: G = __r_arr[3]; + let __v_136: G = __r_arr[4]; + let __v_137: G = __r_arr[5]; + let __v_138: G = __r_arr[6]; + let __v_139: G = __r_arr[7]; + let __v_140: G = __r_arr[8]; + let __v_141: G = __r_arr[9]; + let __v_142: G = __r_arr[10]; + let __v_143: G = __r_arr[11]; + let __v_144: G = __r_arr[12]; + let __v_145: G = __r_arr[13]; + let __v_146: G = __r_arr[14]; + let __v_147: G = __r_arr[15]; + let __v_148: G = __r_arr[16]; + let __v_149: G = __r_arr[17]; + let __v_150: G = __r_arr[18]; + let __v_151: G = __r_arr[19]; + let __v_152: G = __r_arr[20]; + let __v_153: G = __r_arr[21]; + let __v_154: G = __r_arr[22]; + let __v_155: G = __r_arr[23]; + let __v_156: G = __r_arr[24]; + let __v_157: G = __r_arr[25]; + let __v_158: G = __r_arr[26]; + let __v_159: G = __r_arr[27]; + let __v_160: G = __r_arr[28]; + let __v_161: G = __r_arr[29]; + let __v_162: G = __r_arr[30]; + let __v_163: G = __r_arr[31]; + let __v_164: G = { let __values: [G; 34] = [__v_91, __v_5, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_26] = [__v_164]; + record.function_queries[26].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_27], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(2); + let __v_8: G = G::from_u64(8); + let __r_arr: [G; OUT_24] = { let __args: [G; IN_24] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[24].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_24] = unsafe { *(result.output.as_ptr() as *const [G; OUT_24]) }; __ret } else { aiur_fn_24(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __v_11: G = __r_arr[2]; + let __v_12: G = __r_arr[3]; + let __v_13: G = __r_arr[4]; + let __v_14: G = __r_arr[5]; + let __v_15: G = __r_arr[6]; + let __v_16: G = __r_arr[7]; + let __v_17: G = __r_arr[8]; + let __v_18: G = __r_arr[9]; + let __v_19: G = __r_arr[10]; + let __v_20: G = __r_arr[11]; + let __v_21: G = __r_arr[12]; + let __v_22: G = __r_arr[13]; + let __v_23: G = __r_arr[14]; + let __v_24: G = __r_arr[15]; + let __v_25: G = __r_arr[16]; + let __v_26: G = __r_arr[17]; + let __v_27: G = __r_arr[18]; + let __v_28: G = __r_arr[19]; + let __v_29: G = __r_arr[20]; + let __v_30: G = __r_arr[21]; + let __v_31: G = __r_arr[22]; + let __v_32: G = __r_arr[23]; + let __v_33: G = __r_arr[24]; + let __v_34: G = __r_arr[25]; + let __v_35: G = __r_arr[26]; + let __v_36: G = __r_arr[27]; + let __v_37: G = __r_arr[28]; + let __v_38: G = __r_arr[29]; + let __v_39: G = __r_arr[30]; + let __v_40: G = __r_arr[31]; + let __v_41: G = __r_arr[32]; + let __v_42: G = __r_arr[33]; + let __v_43: G = __r_arr[34]; + let __v_44: G = __r_arr[35]; + let __v_45: G = __r_arr[36]; + let __v_46: G = __r_arr[37]; + let __v_47: G = __r_arr[38]; + let __v_48: G = __r_arr[39]; + let __v_49: G = __r_arr[40]; + let __v_50: G = __r_arr[41]; + let __v_51: G = __r_arr[42]; + let __v_52: G = __r_arr[43]; + let __v_53: G = __r_arr[44]; + let __v_54: G = __r_arr[45]; + let __v_55: G = __r_arr[46]; + let __v_56: G = __r_arr[47]; + let __v_57: G = __r_arr[48]; + let __v_58: G = __r_arr[49]; + let __v_59: G = __r_arr[50]; + let __v_60: G = __r_arr[51]; + let __v_61: G = __r_arr[52]; + let __v_62: G = __r_arr[53]; + let __v_63: G = __r_arr[54]; + let __v_64: G = __r_arr[55]; + let __v_65: G = __r_arr[56]; + let __v_66: G = __r_arr[57]; + let __v_67: G = __r_arr[58]; + let __v_68: G = __r_arr[59]; + let __v_69: G = __r_arr[60]; + let __v_70: G = __r_arr[61]; + let __v_71: G = __r_arr[62]; + let __v_72: G = __r_arr[63]; + match __v_2.as_canonical_u64() { + 1023u64 => { + 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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [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_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]; + let __v_75: G = __loaded[1]; + let __v_76: G = __loaded[2]; + let __v_77: G = __loaded[3]; + let __v_78: G = __loaded[4]; + let __v_79: G = __loaded[5]; + let __v_80: G = __loaded[6]; + let __v_81: G = __loaded[7]; + 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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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); + let __v_85: G = (__v_84 + __v_7); + let __v_86: G = G::from_u64(103); + let __v_87: G = G::from_u64(230); + let __v_88: G = G::from_u64(9); + let __v_89: G = G::from_u64(106); + let __v_90: G = G::from_u64(133); + let __v_91: G = G::from_u64(174); + let __v_92: G = G::from_u64(103); + let __v_93: G = G::from_u64(187); + let __v_94: G = G::from_u64(114); + let __v_95: G = G::from_u64(243); + let __v_96: G = G::from_u64(110); + let __v_97: G = G::from_u64(60); + let __v_98: G = G::from_u64(58); + let __v_99: G = G::from_u64(245); + let __v_100: G = G::from_u64(79); + let __v_101: G = G::from_u64(165); + let __v_102: G = G::from_u64(127); + let __v_103: G = G::from_u64(82); + let __v_104: G = G::from_u64(14); + let __v_105: G = G::from_u64(81); + let __v_106: G = G::from_u64(140); + let __v_107: G = G::from_u64(104); + let __v_108: G = G::from_u64(5); + let __v_109: G = G::from_u64(155); + let __v_110: G = G::from_u64(171); + let __v_111: G = G::from_u64(217); + let __v_112: G = G::from_u64(131); + let __v_113: G = G::from_u64(31); + let __v_114: G = G::from_u64(25); + let __v_115: G = G::from_u64(205); + let __v_116: G = G::from_u64(224); + let __v_117: G = G::from_u64(91); + let __v_118: G = G::from_u64(0); + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_119: G = __loaded[0]; + let __v_120: G = __loaded[1]; + let __v_121: G = __loaded[2]; + let __v_122: G = __loaded[3]; + let __v_123: G = __loaded[4]; + let __v_124: G = __loaded[5]; + let __v_125: G = __loaded[6]; + let __v_126: G = __loaded[7]; + let __v_127: G = __loaded[8]; + let __v_128: G = __loaded[9]; + let __v_129: G = __loaded[10]; + let __v_130: G = __loaded[11]; + let __v_131: G = __loaded[12]; + let __v_132: G = __loaded[13]; + let __v_133: G = __loaded[14]; + let __v_134: G = __loaded[15]; + let __v_135: G = __loaded[16]; + let __v_136: G = __loaded[17]; + let __v_137: G = __loaded[18]; + let __v_138: G = __loaded[19]; + let __v_139: G = __loaded[20]; + let __v_140: G = __loaded[21]; + let __v_141: G = __loaded[22]; + let __v_142: G = __loaded[23]; + let __v_143: G = __loaded[24]; + let __v_144: G = __loaded[25]; + let __v_145: G = __loaded[26]; + let __v_146: G = __loaded[27]; + let __v_147: G = __loaded[28]; + let __v_148: G = __loaded[29]; + let __v_149: G = __loaded[30]; + let __v_150: G = __loaded[31]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_151: G = __loaded[0]; + let __v_152: G = __loaded[1]; + let __v_153: G = __loaded[2]; + let __v_154: G = __loaded[3]; + let __v_155: G = __loaded[4]; + let __v_156: G = __loaded[5]; + let __v_157: G = __loaded[6]; + let __v_158: G = __loaded[7]; + let __v_159: G = G::from_u64(64); + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__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_150, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __v_160: G = __r_arr[0]; + let __v_161: G = __r_arr[1]; + let __v_162: G = __r_arr[2]; + let __v_163: G = __r_arr[3]; + let __v_164: G = __r_arr[4]; + let __v_165: G = __r_arr[5]; + let __v_166: G = __r_arr[6]; + let __v_167: G = __r_arr[7]; + let __v_168: G = __r_arr[8]; + let __v_169: G = __r_arr[9]; + let __v_170: G = __r_arr[10]; + let __v_171: G = __r_arr[11]; + let __v_172: G = __r_arr[12]; + let __v_173: G = __r_arr[13]; + let __v_174: G = __r_arr[14]; + let __v_175: G = __r_arr[15]; + let __v_176: G = __r_arr[16]; + let __v_177: G = __r_arr[17]; + let __v_178: G = __r_arr[18]; + let __v_179: G = __r_arr[19]; + let __v_180: G = __r_arr[20]; + let __v_181: G = __r_arr[21]; + let __v_182: G = __r_arr[22]; + let __v_183: G = __r_arr[23]; + let __v_184: G = __r_arr[24]; + let __v_185: G = __r_arr[25]; + let __v_186: G = __r_arr[26]; + let __v_187: G = __r_arr[27]; + let __v_188: G = __r_arr[28]; + let __v_189: G = __r_arr[29]; + let __v_190: G = __r_arr[30]; + let __v_191: G = __r_arr[31]; + let __v_192: G = { let __values: [G; 34] = [__v_118, __v_5, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165, __v_166, __v_167, __v_168, __v_169, __v_170, __v_171, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177, __v_178, __v_179, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185, __v_186, __v_187, __v_188, __v_189, __v_190, __v_191]; let __mq = record.memory_queries.get_mut(&34).ok_or(ExecError::InvalidMemorySize(34))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_193: G = G::from_u64(1); + let __v_194: G = G::from_u64(1); + let __v_195: G = { let __values: [G; 3] = [__v_193, __v_194, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_196: G = G::from_u64(0); + let __v_197: G = G::from_u64(0); + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 8 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 8] = __args[..8].try_into().unwrap(); __arr }; + let __v_198: G = __loaded[0]; + let __v_199: G = __loaded[1]; + let __v_200: G = __loaded[2]; + let __v_201: G = __loaded[3]; + let __v_202: G = __loaded[4]; + let __v_203: G = __loaded[5]; + let __v_204: G = __loaded[6]; + let __v_205: G = __loaded[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__v_198, __v_199, __v_200, __v_201, __v_202, __v_203, __v_204, __v_205]; let __cu = unconstrained; if let Some(result) = record.function_queries[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_206: G = __r_arr[0]; + let __v_207: G = __r_arr[1]; + let __v_208: G = __r_arr[2]; + let __v_209: G = __r_arr[3]; + let __v_210: G = __r_arr[4]; + let __v_211: G = __r_arr[5]; + let __v_212: G = __r_arr[6]; + let __v_213: G = __r_arr[7]; + let __v_214: G = { let __values: [G; 8] = [__v_206, __v_207, __v_208, __v_209, __v_210, __v_211, __v_212, __v_213]; let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_215: G = { let __values: [G; 32] = [__v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0, __v_195, __v_196, __v_197, __v_214, __v_215, __v_192]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __v_216: G = __r_arr[0]; + let __ret: [G; OUT_27] = [__v_216]; + record.function_queries[27].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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [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_73: G = __r_arr[0]; + let __v_74: G = (__v_73 * __v_7); + 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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [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_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]; + let __v_77: G = __loaded[1]; + let __v_78: G = __loaded[2]; + let __v_79: G = __loaded[3]; + let __v_80: G = __loaded[4]; + let __v_81: G = __loaded[5]; + let __v_82: G = __loaded[6]; + let __v_83: G = __loaded[7]; + 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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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); + let __v_87: G = G::from_u64(63); + let __v_88: G = (__v_2 - __v_87); + let __v_89: G = G::from_bool((__v_88 == G::ZERO)); + let __v_90: G = (__v_89 * __v_6); + let __v_91: G = (__v_86 + __v_90); + let __v_92: G = (__v_74 + __v_91); + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_93: G = __loaded[0]; + let __v_94: G = __loaded[1]; + let __v_95: G = __loaded[2]; + let __v_96: G = __loaded[3]; + let __v_97: G = __loaded[4]; + let __v_98: G = __loaded[5]; + let __v_99: G = __loaded[6]; + let __v_100: G = __loaded[7]; + let __v_101: G = __loaded[8]; + let __v_102: G = __loaded[9]; + let __v_103: G = __loaded[10]; + let __v_104: G = __loaded[11]; + let __v_105: G = __loaded[12]; + let __v_106: G = __loaded[13]; + let __v_107: G = __loaded[14]; + let __v_108: G = __loaded[15]; + let __v_109: G = __loaded[16]; + let __v_110: G = __loaded[17]; + let __v_111: G = __loaded[18]; + let __v_112: G = __loaded[19]; + let __v_113: G = __loaded[20]; + let __v_114: G = __loaded[21]; + let __v_115: G = __loaded[22]; + let __v_116: G = __loaded[23]; + let __v_117: G = __loaded[24]; + let __v_118: G = __loaded[25]; + let __v_119: G = __loaded[26]; + let __v_120: G = __loaded[27]; + let __v_121: G = __loaded[28]; + let __v_122: G = __loaded[29]; + let __v_123: G = __loaded[30]; + let __v_124: G = __loaded[31]; + let __loaded: [G; 8] = { let __mq = record.memory_queries.get_mut(&8).ok_or(ExecError::InvalidMemorySize(8))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_125: G = __loaded[0]; + let __v_126: G = __loaded[1]; + let __v_127: G = __loaded[2]; + let __v_128: G = __loaded[3]; + let __v_129: G = __loaded[4]; + let __v_130: G = __loaded[5]; + let __v_131: G = __loaded[6]; + let __v_132: G = __loaded[7]; + let __v_133: G = G::from_u64(64); + let __r_arr: [G; OUT_30] = { let __args: [G; IN_30] = [__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_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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_125, __v_126, __v_127, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_92]; let __cu = unconstrained; if let Some(result) = record.function_queries[30].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_30] = unsafe { *(result.output.as_ptr() as *const [G; OUT_30]) }; __ret } else { aiur_fn_30(__args, record, io_buffer, __cu)? } }; + let __v_134: G = __r_arr[0]; + let __v_135: G = __r_arr[1]; + let __v_136: G = __r_arr[2]; + let __v_137: G = __r_arr[3]; + let __v_138: G = __r_arr[4]; + let __v_139: G = __r_arr[5]; + let __v_140: G = __r_arr[6]; + let __v_141: G = __r_arr[7]; + let __v_142: G = __r_arr[8]; + let __v_143: G = __r_arr[9]; + let __v_144: G = __r_arr[10]; + let __v_145: G = __r_arr[11]; + let __v_146: G = __r_arr[12]; + let __v_147: G = __r_arr[13]; + let __v_148: G = __r_arr[14]; + let __v_149: G = __r_arr[15]; + let __v_150: G = __r_arr[16]; + let __v_151: G = __r_arr[17]; + let __v_152: G = __r_arr[18]; + let __v_153: G = __r_arr[19]; + let __v_154: G = __r_arr[20]; + let __v_155: G = __r_arr[21]; + let __v_156: G = __r_arr[22]; + let __v_157: G = __r_arr[23]; + let __v_158: G = __r_arr[24]; + let __v_159: G = __r_arr[25]; + let __v_160: G = __r_arr[26]; + let __v_161: G = __r_arr[27]; + let __v_162: G = __r_arr[28]; + let __v_163: G = __r_arr[29]; + let __v_164: G = __r_arr[30]; + let __v_165: G = __r_arr[31]; + let __v_166: G = G::from_u64(1); + let __v_167: G = G::from_u64(1); + let __v_168: G = { let __values: [G; 3] = [__v_166, __v_167, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_169: G = G::from_u64(0); + let __v_170: G = G::from_u64(1); + let __v_171: G = (__v_2 + __v_170); + let __v_172: G = { let __values: [G; 32] = [__v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157, __v_158, __v_159, __v_160, __v_161, __v_162, __v_163, __v_164, __v_165]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_23] = { let __args: [G; IN_23] = [__v_0, __v_168, __v_169, __v_171, __v_3, __v_172, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[23].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_23] = unsafe { *(result.output.as_ptr() as *const [G; OUT_23]) }; __ret } else { aiur_fn_23(__args, record, io_buffer, __cu)? } }; + let __v_173: G = __r_arr[0]; + let __ret: [G; OUT_27] = [__v_173]; + record.function_queries[27].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_28: usize = 24; +const IN_28: usize = 24; +const OUT_28: usize = 16; +fn aiur_fn_28( + inp: [G; IN_28], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_28], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_0, &__v_4) } else { bytes2_add_value(__v_0, __v_4, record) }; + let __v_24: G = __b2_add.0; + let __v_25: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_1, &__v_5) } else { bytes2_add_value(__v_1, __v_5, record) }; + let __v_26: G = __b2_add.0; + let __v_27: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_26, &__v_25) } else { bytes2_add_value(__v_26, __v_25, record) }; + let __v_28: G = __b2_add.0; + let __v_29: G = __b2_add.1; + let __v_30: G = (__v_27 + __v_29); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_2, &__v_6) } else { bytes2_add_value(__v_2, __v_6, record) }; + let __v_31: G = __b2_add.0; + let __v_32: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_31, &__v_30) } else { bytes2_add_value(__v_31, __v_30, record) }; + let __v_33: G = __b2_add.0; + let __v_34: G = __b2_add.1; + let __v_35: G = (__v_32 + __v_34); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_3, &__v_7) } else { bytes2_add_value(__v_3, __v_7, record) }; + let __v_36: G = __b2_add.0; + let __v_37: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_36, &__v_35) } else { bytes2_add_value(__v_36, __v_35, record) }; + let __v_38: G = __b2_add.0; + let __v_39: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_24, &__v_16) } else { bytes2_add_value(__v_24, __v_16, record) }; + let __v_40: G = __b2_add.0; + let __v_41: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_28, &__v_17) } else { bytes2_add_value(__v_28, __v_17, record) }; + let __v_42: G = __b2_add.0; + let __v_43: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_42, &__v_41) } else { bytes2_add_value(__v_42, __v_41, record) }; + let __v_44: G = __b2_add.0; + let __v_45: G = __b2_add.1; + let __v_46: G = (__v_43 + __v_45); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_33, &__v_18) } else { bytes2_add_value(__v_33, __v_18, record) }; + let __v_47: G = __b2_add.0; + let __v_48: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_47, &__v_46) } else { bytes2_add_value(__v_47, __v_46, record) }; + let __v_49: G = __b2_add.0; + let __v_50: G = __b2_add.1; + let __v_51: G = (__v_48 + __v_50); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_38, &__v_19) } else { bytes2_add_value(__v_38, __v_19, record) }; + let __v_52: G = __b2_add.0; + let __v_53: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_52, &__v_51) } else { bytes2_add_value(__v_52, __v_51, record) }; + let __v_54: G = __b2_add.0; + let __v_55: G = __b2_add.1; + let __v_56: G = if unconstrained { Bytes2::xor(&__v_12, &__v_40) } else { bytes2_xor_value(__v_12, __v_40, record) }; + let __v_57: G = if unconstrained { Bytes2::xor(&__v_13, &__v_44) } else { bytes2_xor_value(__v_13, __v_44, record) }; + let __v_58: G = if unconstrained { Bytes2::xor(&__v_14, &__v_49) } else { bytes2_xor_value(__v_14, __v_49, record) }; + let __v_59: G = if unconstrained { Bytes2::xor(&__v_15, &__v_54) } else { bytes2_xor_value(__v_15, __v_54, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_8, &__v_58) } else { bytes2_add_value(__v_8, __v_58, record) }; + let __v_60: G = __b2_add.0; + let __v_61: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_9, &__v_59) } else { bytes2_add_value(__v_9, __v_59, record) }; + let __v_62: G = __b2_add.0; + let __v_63: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_62, &__v_61) } else { bytes2_add_value(__v_62, __v_61, record) }; + let __v_64: G = __b2_add.0; + let __v_65: G = __b2_add.1; + let __v_66: G = (__v_63 + __v_65); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_10, &__v_56) } else { bytes2_add_value(__v_10, __v_56, record) }; + let __v_67: G = __b2_add.0; + let __v_68: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_67, &__v_66) } else { bytes2_add_value(__v_67, __v_66, record) }; + let __v_69: G = __b2_add.0; + let __v_70: G = __b2_add.1; + let __v_71: G = (__v_68 + __v_70); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_11, &__v_57) } else { bytes2_add_value(__v_11, __v_57, record) }; + let __v_72: G = __b2_add.0; + let __v_73: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_72, &__v_71) } else { bytes2_add_value(__v_72, __v_71, record) }; + let __v_74: G = __b2_add.0; + let __v_75: G = __b2_add.1; + let __v_76: G = if unconstrained { Bytes2::xor(&__v_4, &__v_60) } else { bytes2_xor_value(__v_4, __v_60, record) }; + let __v_77: G = if unconstrained { Bytes2::xor(&__v_5, &__v_64) } else { bytes2_xor_value(__v_5, __v_64, record) }; + let __v_78: G = if unconstrained { Bytes2::xor(&__v_6, &__v_69) } else { bytes2_xor_value(__v_6, __v_69, record) }; + let __v_79: G = if unconstrained { Bytes2::xor(&__v_7, &__v_74) } else { bytes2_xor_value(__v_7, __v_74, record) }; + let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr4(&__v_77, &__v_78) } else { bytes2_chain_rotr4_value(__v_77, __v_78, record) }; + let __v_80: G = __b2_out.0; + let __v_81: G = __b2_out.1; + let __v_82: G = __b2_out.2; + let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr4(&__v_79, &__v_76) } else { bytes2_chain_rotr4_value(__v_79, __v_76, record) }; + let __v_83: G = __b2_out.0; + let __v_84: G = __b2_out.1; + let __v_85: G = __b2_out.2; + let __v_86: G = (__v_81 + __v_85); + let __v_87: G = (__v_84 + __v_82); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_40, &__v_80) } else { bytes2_add_value(__v_40, __v_80, record) }; + let __v_88: G = __b2_add.0; + let __v_89: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_44, &__v_86) } else { bytes2_add_value(__v_44, __v_86, record) }; + let __v_90: G = __b2_add.0; + let __v_91: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_90, &__v_89) } else { bytes2_add_value(__v_90, __v_89, record) }; + let __v_92: G = __b2_add.0; + let __v_93: G = __b2_add.1; + let __v_94: G = (__v_91 + __v_93); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_49, &__v_83) } else { bytes2_add_value(__v_49, __v_83, record) }; + let __v_95: G = __b2_add.0; + let __v_96: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_95, &__v_94) } else { bytes2_add_value(__v_95, __v_94, record) }; + let __v_97: G = __b2_add.0; + let __v_98: G = __b2_add.1; + let __v_99: G = (__v_96 + __v_98); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_54, &__v_87) } else { bytes2_add_value(__v_54, __v_87, record) }; + let __v_100: G = __b2_add.0; + let __v_101: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_100, &__v_99) } else { bytes2_add_value(__v_100, __v_99, record) }; + let __v_102: G = __b2_add.0; + let __v_103: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_88, &__v_20) } else { bytes2_add_value(__v_88, __v_20, record) }; + let __v_104: G = __b2_add.0; + let __v_105: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_92, &__v_21) } else { bytes2_add_value(__v_92, __v_21, record) }; + let __v_106: G = __b2_add.0; + let __v_107: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_106, &__v_105) } else { bytes2_add_value(__v_106, __v_105, record) }; + let __v_108: G = __b2_add.0; + let __v_109: G = __b2_add.1; + let __v_110: G = (__v_107 + __v_109); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_97, &__v_22) } else { bytes2_add_value(__v_97, __v_22, record) }; + let __v_111: G = __b2_add.0; + let __v_112: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_111, &__v_110) } else { bytes2_add_value(__v_111, __v_110, record) }; + let __v_113: G = __b2_add.0; + let __v_114: G = __b2_add.1; + let __v_115: G = (__v_112 + __v_114); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_102, &__v_23) } else { bytes2_add_value(__v_102, __v_23, record) }; + let __v_116: G = __b2_add.0; + let __v_117: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_116, &__v_115) } else { bytes2_add_value(__v_116, __v_115, record) }; + let __v_118: G = __b2_add.0; + let __v_119: G = __b2_add.1; + let __v_120: G = if unconstrained { Bytes2::xor(&__v_58, &__v_104) } else { bytes2_xor_value(__v_58, __v_104, record) }; + let __v_121: G = if unconstrained { Bytes2::xor(&__v_59, &__v_108) } else { bytes2_xor_value(__v_59, __v_108, record) }; + let __v_122: G = if unconstrained { Bytes2::xor(&__v_56, &__v_113) } else { bytes2_xor_value(__v_56, __v_113, record) }; + let __v_123: G = if unconstrained { Bytes2::xor(&__v_57, &__v_118) } else { bytes2_xor_value(__v_57, __v_118, record) }; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_60, &__v_121) } else { bytes2_add_value(__v_60, __v_121, record) }; + let __v_124: G = __b2_add.0; + let __v_125: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_64, &__v_122) } else { bytes2_add_value(__v_64, __v_122, record) }; + let __v_126: G = __b2_add.0; + let __v_127: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_126, &__v_125) } else { bytes2_add_value(__v_126, __v_125, record) }; + let __v_128: G = __b2_add.0; + let __v_129: G = __b2_add.1; + let __v_130: G = (__v_127 + __v_129); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_69, &__v_123) } else { bytes2_add_value(__v_69, __v_123, record) }; + let __v_131: G = __b2_add.0; + let __v_132: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_131, &__v_130) } else { bytes2_add_value(__v_131, __v_130, record) }; + let __v_133: G = __b2_add.0; + let __v_134: G = __b2_add.1; + let __v_135: G = (__v_132 + __v_134); + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_74, &__v_120) } else { bytes2_add_value(__v_74, __v_120, record) }; + let __v_136: G = __b2_add.0; + let __v_137: G = __b2_add.1; + let __b2_add: (G, G) = if unconstrained { Bytes2::add(&__v_136, &__v_135) } else { bytes2_add_value(__v_136, __v_135, record) }; + let __v_138: G = __b2_add.0; + let __v_139: G = __b2_add.1; + let __v_140: G = if unconstrained { Bytes2::xor(&__v_80, &__v_124) } else { bytes2_xor_value(__v_80, __v_124, record) }; + let __v_141: G = if unconstrained { Bytes2::xor(&__v_86, &__v_128) } else { bytes2_xor_value(__v_86, __v_128, record) }; + let __v_142: G = if unconstrained { Bytes2::xor(&__v_83, &__v_133) } else { bytes2_xor_value(__v_83, __v_133, record) }; + let __v_143: G = if unconstrained { Bytes2::xor(&__v_87, &__v_138) } else { bytes2_xor_value(__v_87, __v_138, record) }; + let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr7(&__v_140, &__v_141) } else { bytes2_chain_rotr7_value(__v_140, __v_141, record) }; + let __v_144: G = __b2_out.0; + let __v_145: G = __b2_out.1; + let __v_146: G = __b2_out.2; + let __b2_out: (G, G, G) = if unconstrained { Bytes2::chain_rotr7(&__v_142, &__v_143) } else { bytes2_chain_rotr7_value(__v_142, __v_143, record) }; + let __v_147: G = __b2_out.0; + let __v_148: G = __b2_out.1; + let __v_149: G = __b2_out.2; + let __v_150: G = (__v_145 + __v_149); + let __v_151: G = (__v_148 + __v_146); + let __ret: [G; OUT_28] = [__v_104, __v_108, __v_113, __v_118, __v_144, __v_150, __v_147, __v_151, __v_124, __v_128, __v_133, __v_138, __v_121, __v_122, __v_123, __v_120]; + record.function_queries[28].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_29: usize = 128; +const IN_29: usize = 128; +const OUT_29: usize = 128; +fn aiur_fn_29( + inp: [G; IN_29], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_29], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + let __v_51: G = inp[51]; + let __v_52: G = inp[52]; + let __v_53: G = inp[53]; + let __v_54: G = inp[54]; + let __v_55: G = inp[55]; + let __v_56: G = inp[56]; + let __v_57: G = inp[57]; + let __v_58: G = inp[58]; + let __v_59: G = inp[59]; + let __v_60: G = inp[60]; + let __v_61: G = inp[61]; + let __v_62: G = inp[62]; + let __v_63: G = inp[63]; + let __v_64: G = inp[64]; + let __v_65: G = inp[65]; + let __v_66: G = inp[66]; + let __v_67: G = inp[67]; + let __v_68: G = inp[68]; + let __v_69: G = inp[69]; + let __v_70: G = inp[70]; + let __v_71: G = inp[71]; + let __v_72: G = inp[72]; + let __v_73: G = inp[73]; + let __v_74: G = inp[74]; + let __v_75: G = inp[75]; + let __v_76: G = inp[76]; + let __v_77: G = inp[77]; + let __v_78: G = inp[78]; + let __v_79: G = inp[79]; + let __v_80: G = inp[80]; + let __v_81: G = inp[81]; + let __v_82: G = inp[82]; + let __v_83: G = inp[83]; + let __v_84: G = inp[84]; + let __v_85: G = inp[85]; + let __v_86: G = inp[86]; + let __v_87: G = inp[87]; + let __v_88: G = inp[88]; + let __v_89: G = inp[89]; + let __v_90: G = inp[90]; + let __v_91: G = inp[91]; + let __v_92: G = inp[92]; + let __v_93: G = inp[93]; + let __v_94: G = inp[94]; + let __v_95: G = inp[95]; + let __v_96: G = inp[96]; + let __v_97: G = inp[97]; + let __v_98: G = inp[98]; + let __v_99: G = inp[99]; + let __v_100: G = inp[100]; + let __v_101: G = inp[101]; + let __v_102: G = inp[102]; + let __v_103: G = inp[103]; + let __v_104: G = inp[104]; + let __v_105: G = inp[105]; + let __v_106: G = inp[106]; + let __v_107: G = inp[107]; + let __v_108: G = inp[108]; + let __v_109: G = inp[109]; + let __v_110: G = inp[110]; + let __v_111: G = inp[111]; + let __v_112: G = inp[112]; + let __v_113: G = inp[113]; + let __v_114: G = inp[114]; + let __v_115: G = inp[115]; + let __v_116: G = inp[116]; + let __v_117: G = inp[117]; + let __v_118: G = inp[118]; + let __v_119: G = inp[119]; + let __v_120: G = inp[120]; + let __v_121: G = inp[121]; + let __v_122: G = inp[122]; + let __v_123: G = inp[123]; + let __v_124: G = inp[124]; + let __v_125: G = inp[125]; + let __v_126: G = inp[126]; + let __v_127: G = inp[127]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_0, __v_1, __v_2, __v_3, __v_16, __v_17, __v_18, __v_19, __v_32, __v_33, __v_34, __v_35, __v_48, __v_49, __v_50, __v_51, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_128: G = __r_arr[0]; + let __v_129: G = __r_arr[1]; + let __v_130: G = __r_arr[2]; + let __v_131: G = __r_arr[3]; + let __v_132: G = __r_arr[4]; + let __v_133: G = __r_arr[5]; + let __v_134: G = __r_arr[6]; + let __v_135: G = __r_arr[7]; + let __v_136: G = __r_arr[8]; + let __v_137: G = __r_arr[9]; + let __v_138: G = __r_arr[10]; + let __v_139: G = __r_arr[11]; + let __v_140: G = __r_arr[12]; + let __v_141: G = __r_arr[13]; + let __v_142: G = __r_arr[14]; + let __v_143: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_4, __v_5, __v_6, __v_7, __v_20, __v_21, __v_22, __v_23, __v_36, __v_37, __v_38, __v_39, __v_52, __v_53, __v_54, __v_55, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_144: G = __r_arr[0]; + let __v_145: G = __r_arr[1]; + let __v_146: G = __r_arr[2]; + let __v_147: G = __r_arr[3]; + let __v_148: G = __r_arr[4]; + let __v_149: G = __r_arr[5]; + let __v_150: G = __r_arr[6]; + let __v_151: G = __r_arr[7]; + let __v_152: G = __r_arr[8]; + let __v_153: G = __r_arr[9]; + let __v_154: G = __r_arr[10]; + let __v_155: G = __r_arr[11]; + let __v_156: G = __r_arr[12]; + let __v_157: G = __r_arr[13]; + let __v_158: G = __r_arr[14]; + let __v_159: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_8, __v_9, __v_10, __v_11, __v_24, __v_25, __v_26, __v_27, __v_40, __v_41, __v_42, __v_43, __v_56, __v_57, __v_58, __v_59, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_160: G = __r_arr[0]; + let __v_161: G = __r_arr[1]; + let __v_162: G = __r_arr[2]; + let __v_163: G = __r_arr[3]; + let __v_164: G = __r_arr[4]; + let __v_165: G = __r_arr[5]; + let __v_166: G = __r_arr[6]; + let __v_167: G = __r_arr[7]; + let __v_168: G = __r_arr[8]; + let __v_169: G = __r_arr[9]; + let __v_170: G = __r_arr[10]; + let __v_171: G = __r_arr[11]; + let __v_172: G = __r_arr[12]; + let __v_173: G = __r_arr[13]; + let __v_174: G = __r_arr[14]; + let __v_175: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_12, __v_13, __v_14, __v_15, __v_28, __v_29, __v_30, __v_31, __v_44, __v_45, __v_46, __v_47, __v_60, __v_61, __v_62, __v_63, __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[28].get_mut(&__args[..]) { 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_176: G = __r_arr[0]; + let __v_177: G = __r_arr[1]; + let __v_178: G = __r_arr[2]; + let __v_179: G = __r_arr[3]; + let __v_180: G = __r_arr[4]; + let __v_181: G = __r_arr[5]; + let __v_182: G = __r_arr[6]; + let __v_183: G = __r_arr[7]; + let __v_184: G = __r_arr[8]; + let __v_185: G = __r_arr[9]; + let __v_186: G = __r_arr[10]; + let __v_187: G = __r_arr[11]; + let __v_188: G = __r_arr[12]; + let __v_189: G = __r_arr[13]; + let __v_190: G = __r_arr[14]; + let __v_191: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_128, __v_129, __v_130, __v_131, __v_148, __v_149, __v_150, __v_151, __v_168, __v_169, __v_170, __v_171, __v_188, __v_189, __v_190, __v_191, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_192: G = __r_arr[0]; + let __v_193: G = __r_arr[1]; + let __v_194: G = __r_arr[2]; + let __v_195: G = __r_arr[3]; + let __v_196: G = __r_arr[4]; + let __v_197: G = __r_arr[5]; + let __v_198: G = __r_arr[6]; + let __v_199: G = __r_arr[7]; + let __v_200: G = __r_arr[8]; + let __v_201: G = __r_arr[9]; + let __v_202: G = __r_arr[10]; + let __v_203: G = __r_arr[11]; + let __v_204: G = __r_arr[12]; + let __v_205: G = __r_arr[13]; + let __v_206: G = __r_arr[14]; + let __v_207: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_144, __v_145, __v_146, __v_147, __v_164, __v_165, __v_166, __v_167, __v_184, __v_185, __v_186, __v_187, __v_140, __v_141, __v_142, __v_143, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_208: G = __r_arr[0]; + let __v_209: G = __r_arr[1]; + let __v_210: G = __r_arr[2]; + let __v_211: G = __r_arr[3]; + let __v_212: G = __r_arr[4]; + let __v_213: G = __r_arr[5]; + let __v_214: G = __r_arr[6]; + let __v_215: G = __r_arr[7]; + let __v_216: G = __r_arr[8]; + let __v_217: G = __r_arr[9]; + let __v_218: G = __r_arr[10]; + let __v_219: G = __r_arr[11]; + let __v_220: G = __r_arr[12]; + let __v_221: G = __r_arr[13]; + let __v_222: G = __r_arr[14]; + let __v_223: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_160, __v_161, __v_162, __v_163, __v_180, __v_181, __v_182, __v_183, __v_136, __v_137, __v_138, __v_139, __v_156, __v_157, __v_158, __v_159, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_224: G = __r_arr[0]; + let __v_225: G = __r_arr[1]; + let __v_226: G = __r_arr[2]; + let __v_227: G = __r_arr[3]; + let __v_228: G = __r_arr[4]; + let __v_229: G = __r_arr[5]; + let __v_230: G = __r_arr[6]; + let __v_231: G = __r_arr[7]; + let __v_232: G = __r_arr[8]; + let __v_233: G = __r_arr[9]; + let __v_234: G = __r_arr[10]; + let __v_235: G = __r_arr[11]; + let __v_236: G = __r_arr[12]; + let __v_237: G = __r_arr[13]; + let __v_238: G = __r_arr[14]; + let __v_239: G = __r_arr[15]; + let __r_arr: [G; OUT_28] = { let __args: [G; IN_28] = [__v_176, __v_177, __v_178, __v_179, __v_132, __v_133, __v_134, __v_135, __v_152, __v_153, __v_154, __v_155, __v_172, __v_173, __v_174, __v_175, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; let __cu = unconstrained; if let Some(result) = record.function_queries[28].get_mut(&__args[..]) { 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_240: G = __r_arr[0]; + let __v_241: G = __r_arr[1]; + let __v_242: G = __r_arr[2]; + let __v_243: G = __r_arr[3]; + let __v_244: G = __r_arr[4]; + let __v_245: G = __r_arr[5]; + let __v_246: G = __r_arr[6]; + let __v_247: G = __r_arr[7]; + let __v_248: G = __r_arr[8]; + let __v_249: G = __r_arr[9]; + let __v_250: G = __r_arr[10]; + let __v_251: G = __r_arr[11]; + let __v_252: G = __r_arr[12]; + let __v_253: G = __r_arr[13]; + let __v_254: G = __r_arr[14]; + let __v_255: G = __r_arr[15]; + let __ret: [G; OUT_29] = [__v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_224, __v_225, __v_226, __v_227, __v_240, __v_241, __v_242, __v_243, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_232, __v_233, __v_234, __v_235, __v_248, __v_249, __v_250, __v_251, __v_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_220, __v_221, __v_222, __v_223, __v_236, __v_237, __v_238, __v_239, __v_252, __v_253, __v_254, __v_255, __v_204, __v_205, __v_206, __v_207, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109, __v_110, __v_111, __v_112, __v_113, __v_114, __v_115, __v_116, __v_117, __v_118, __v_119, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125, __v_126, __v_127]; + record.function_queries[29].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_30: usize = 106; +const IN_30: usize = 106; +const OUT_30: usize = 32; +fn aiur_fn_30( + inp: [G; IN_30], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_30], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + let __v_51: G = inp[51]; + let __v_52: G = inp[52]; + let __v_53: G = inp[53]; + let __v_54: G = inp[54]; + let __v_55: G = inp[55]; + let __v_56: G = inp[56]; + let __v_57: G = inp[57]; + let __v_58: G = inp[58]; + let __v_59: G = inp[59]; + let __v_60: G = inp[60]; + let __v_61: G = inp[61]; + let __v_62: G = inp[62]; + let __v_63: G = inp[63]; + let __v_64: G = inp[64]; + let __v_65: G = inp[65]; + let __v_66: G = inp[66]; + let __v_67: G = inp[67]; + let __v_68: G = inp[68]; + let __v_69: G = inp[69]; + let __v_70: G = inp[70]; + let __v_71: G = inp[71]; + let __v_72: G = inp[72]; + let __v_73: G = inp[73]; + let __v_74: G = inp[74]; + let __v_75: G = inp[75]; + let __v_76: G = inp[76]; + let __v_77: G = inp[77]; + let __v_78: G = inp[78]; + let __v_79: G = inp[79]; + let __v_80: G = inp[80]; + let __v_81: G = inp[81]; + let __v_82: G = inp[82]; + let __v_83: G = inp[83]; + let __v_84: G = inp[84]; + let __v_85: G = inp[85]; + let __v_86: G = inp[86]; + let __v_87: G = inp[87]; + let __v_88: G = inp[88]; + let __v_89: G = inp[89]; + let __v_90: G = inp[90]; + let __v_91: G = inp[91]; + let __v_92: G = inp[92]; + let __v_93: G = inp[93]; + let __v_94: G = inp[94]; + let __v_95: G = inp[95]; + let __v_96: G = inp[96]; + let __v_97: G = inp[97]; + let __v_98: G = inp[98]; + let __v_99: G = inp[99]; + let __v_100: G = inp[100]; + let __v_101: G = inp[101]; + let __v_102: G = inp[102]; + let __v_103: G = inp[103]; + let __v_104: G = inp[104]; + let __v_105: G = inp[105]; + let __v_106: G = G::from_u64(103); + let __v_107: G = G::from_u64(230); + let __v_108: G = G::from_u64(9); + let __v_109: G = G::from_u64(106); + let __v_110: G = G::from_u64(133); + let __v_111: G = G::from_u64(174); + let __v_112: G = G::from_u64(103); + let __v_113: G = G::from_u64(187); + let __v_114: G = G::from_u64(114); + let __v_115: G = G::from_u64(243); + let __v_116: G = G::from_u64(110); + let __v_117: G = G::from_u64(60); + let __v_118: G = G::from_u64(58); + let __v_119: G = G::from_u64(245); + let __v_120: G = G::from_u64(79); + let __v_121: G = G::from_u64(165); + let __v_122: G = G::from_u64(0); + let __v_123: G = G::from_u64(0); + let __v_124: G = G::from_u64(0); + let __v_125: G = G::from_u64(0); + let __v_126: G = G::from_u64(0); + let __v_127: G = G::from_u64(0); + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_128: G = __r_arr[0]; + let __v_129: G = __r_arr[1]; + let __v_130: G = __r_arr[2]; + let __v_131: G = __r_arr[3]; + let __v_132: G = __r_arr[4]; + let __v_133: G = __r_arr[5]; + let __v_134: G = __r_arr[6]; + let __v_135: G = __r_arr[7]; + let __v_136: G = __r_arr[8]; + let __v_137: G = __r_arr[9]; + let __v_138: G = __r_arr[10]; + let __v_139: G = __r_arr[11]; + let __v_140: G = __r_arr[12]; + let __v_141: G = __r_arr[13]; + let __v_142: G = __r_arr[14]; + let __v_143: G = __r_arr[15]; + let __v_144: G = __r_arr[16]; + let __v_145: G = __r_arr[17]; + let __v_146: G = __r_arr[18]; + let __v_147: G = __r_arr[19]; + let __v_148: G = __r_arr[20]; + let __v_149: G = __r_arr[21]; + let __v_150: G = __r_arr[22]; + let __v_151: G = __r_arr[23]; + let __v_152: G = __r_arr[24]; + let __v_153: G = __r_arr[25]; + let __v_154: G = __r_arr[26]; + let __v_155: G = __r_arr[27]; + let __v_156: G = __r_arr[28]; + let __v_157: G = __r_arr[29]; + let __v_158: G = __r_arr[30]; + let __v_159: G = __r_arr[31]; + let __v_160: G = __r_arr[32]; + let __v_161: G = __r_arr[33]; + let __v_162: G = __r_arr[34]; + let __v_163: G = __r_arr[35]; + let __v_164: G = __r_arr[36]; + let __v_165: G = __r_arr[37]; + let __v_166: G = __r_arr[38]; + let __v_167: G = __r_arr[39]; + let __v_168: G = __r_arr[40]; + let __v_169: G = __r_arr[41]; + let __v_170: G = __r_arr[42]; + let __v_171: G = __r_arr[43]; + let __v_172: G = __r_arr[44]; + let __v_173: G = __r_arr[45]; + let __v_174: G = __r_arr[46]; + let __v_175: G = __r_arr[47]; + let __v_176: G = __r_arr[48]; + let __v_177: G = __r_arr[49]; + let __v_178: G = __r_arr[50]; + let __v_179: G = __r_arr[51]; + let __v_180: G = __r_arr[52]; + let __v_181: G = __r_arr[53]; + let __v_182: G = __r_arr[54]; + let __v_183: G = __r_arr[55]; + let __v_184: G = __r_arr[56]; + let __v_185: G = __r_arr[57]; + let __v_186: G = __r_arr[58]; + let __v_187: G = __r_arr[59]; + let __v_188: G = __r_arr[60]; + let __v_189: G = __r_arr[61]; + let __v_190: G = __r_arr[62]; + let __v_191: G = __r_arr[63]; + let __v_192: G = __r_arr[64]; + let __v_193: G = __r_arr[65]; + let __v_194: G = __r_arr[66]; + let __v_195: G = __r_arr[67]; + let __v_196: G = __r_arr[68]; + let __v_197: G = __r_arr[69]; + let __v_198: G = __r_arr[70]; + let __v_199: G = __r_arr[71]; + let __v_200: G = __r_arr[72]; + let __v_201: G = __r_arr[73]; + let __v_202: G = __r_arr[74]; + let __v_203: G = __r_arr[75]; + let __v_204: G = __r_arr[76]; + let __v_205: G = __r_arr[77]; + let __v_206: G = __r_arr[78]; + let __v_207: G = __r_arr[79]; + let __v_208: G = __r_arr[80]; + let __v_209: G = __r_arr[81]; + let __v_210: G = __r_arr[82]; + let __v_211: G = __r_arr[83]; + let __v_212: G = __r_arr[84]; + let __v_213: G = __r_arr[85]; + let __v_214: G = __r_arr[86]; + let __v_215: G = __r_arr[87]; + let __v_216: G = __r_arr[88]; + let __v_217: G = __r_arr[89]; + let __v_218: G = __r_arr[90]; + let __v_219: G = __r_arr[91]; + let __v_220: G = __r_arr[92]; + let __v_221: G = __r_arr[93]; + let __v_222: G = __r_arr[94]; + let __v_223: G = __r_arr[95]; + let __v_224: G = __r_arr[96]; + let __v_225: G = __r_arr[97]; + let __v_226: G = __r_arr[98]; + let __v_227: G = __r_arr[99]; + let __v_228: G = __r_arr[100]; + let __v_229: G = __r_arr[101]; + let __v_230: G = __r_arr[102]; + let __v_231: G = __r_arr[103]; + let __v_232: G = __r_arr[104]; + let __v_233: G = __r_arr[105]; + let __v_234: G = __r_arr[106]; + let __v_235: G = __r_arr[107]; + let __v_236: G = __r_arr[108]; + let __v_237: G = __r_arr[109]; + let __v_238: G = __r_arr[110]; + let __v_239: G = __r_arr[111]; + let __v_240: G = __r_arr[112]; + let __v_241: G = __r_arr[113]; + let __v_242: G = __r_arr[114]; + let __v_243: G = __r_arr[115]; + let __v_244: G = __r_arr[116]; + let __v_245: G = __r_arr[117]; + let __v_246: G = __r_arr[118]; + let __v_247: G = __r_arr[119]; + let __v_248: G = __r_arr[120]; + let __v_249: G = __r_arr[121]; + let __v_250: G = __r_arr[122]; + let __v_251: G = __r_arr[123]; + let __v_252: G = __r_arr[124]; + let __v_253: G = __r_arr[125]; + let __v_254: G = __r_arr[126]; + let __v_255: G = __r_arr[127]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_128, __v_129, __v_130, __v_131, __v_132, __v_133, __v_134, __v_135, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149, __v_150, __v_151, __v_152, __v_153, __v_154, __v_155, __v_156, __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, __v_189, __v_190, __v_191, __v_200, __v_201, __v_202, __v_203, __v_216, __v_217, __v_218, __v_219, __v_204, __v_205, __v_206, __v_207, __v_232, __v_233, __v_234, __v_235, __v_220, __v_221, __v_222, __v_223, __v_192, __v_193, __v_194, __v_195, __v_208, __v_209, __v_210, __v_211, __v_244, __v_245, __v_246, __v_247, __v_196, __v_197, __v_198, __v_199, __v_236, __v_237, __v_238, __v_239, __v_240, __v_241, __v_242, __v_243, __v_212, __v_213, __v_214, __v_215, __v_228, __v_229, __v_230, __v_231, __v_248, __v_249, __v_250, __v_251, __v_252, __v_253, __v_254, __v_255, __v_224, __v_225, __v_226, __v_227]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_256: G = __r_arr[0]; + let __v_257: G = __r_arr[1]; + let __v_258: G = __r_arr[2]; + let __v_259: G = __r_arr[3]; + let __v_260: G = __r_arr[4]; + let __v_261: G = __r_arr[5]; + let __v_262: G = __r_arr[6]; + let __v_263: G = __r_arr[7]; + let __v_264: G = __r_arr[8]; + let __v_265: G = __r_arr[9]; + let __v_266: G = __r_arr[10]; + let __v_267: G = __r_arr[11]; + let __v_268: G = __r_arr[12]; + let __v_269: G = __r_arr[13]; + let __v_270: G = __r_arr[14]; + let __v_271: G = __r_arr[15]; + let __v_272: G = __r_arr[16]; + let __v_273: G = __r_arr[17]; + let __v_274: G = __r_arr[18]; + let __v_275: G = __r_arr[19]; + let __v_276: G = __r_arr[20]; + let __v_277: G = __r_arr[21]; + let __v_278: G = __r_arr[22]; + let __v_279: G = __r_arr[23]; + let __v_280: G = __r_arr[24]; + let __v_281: G = __r_arr[25]; + let __v_282: G = __r_arr[26]; + let __v_283: G = __r_arr[27]; + let __v_284: G = __r_arr[28]; + let __v_285: G = __r_arr[29]; + let __v_286: G = __r_arr[30]; + let __v_287: G = __r_arr[31]; + let __v_288: G = __r_arr[32]; + let __v_289: G = __r_arr[33]; + let __v_290: G = __r_arr[34]; + let __v_291: G = __r_arr[35]; + let __v_292: G = __r_arr[36]; + let __v_293: G = __r_arr[37]; + let __v_294: G = __r_arr[38]; + let __v_295: G = __r_arr[39]; + let __v_296: G = __r_arr[40]; + let __v_297: G = __r_arr[41]; + let __v_298: G = __r_arr[42]; + let __v_299: G = __r_arr[43]; + let __v_300: G = __r_arr[44]; + let __v_301: G = __r_arr[45]; + let __v_302: G = __r_arr[46]; + let __v_303: G = __r_arr[47]; + let __v_304: G = __r_arr[48]; + let __v_305: G = __r_arr[49]; + let __v_306: G = __r_arr[50]; + let __v_307: G = __r_arr[51]; + let __v_308: G = __r_arr[52]; + let __v_309: G = __r_arr[53]; + let __v_310: G = __r_arr[54]; + let __v_311: G = __r_arr[55]; + let __v_312: G = __r_arr[56]; + let __v_313: G = __r_arr[57]; + let __v_314: G = __r_arr[58]; + let __v_315: G = __r_arr[59]; + let __v_316: G = __r_arr[60]; + let __v_317: G = __r_arr[61]; + let __v_318: G = __r_arr[62]; + let __v_319: G = __r_arr[63]; + let __v_320: G = __r_arr[64]; + let __v_321: G = __r_arr[65]; + let __v_322: G = __r_arr[66]; + let __v_323: G = __r_arr[67]; + let __v_324: G = __r_arr[68]; + let __v_325: G = __r_arr[69]; + let __v_326: G = __r_arr[70]; + let __v_327: G = __r_arr[71]; + let __v_328: G = __r_arr[72]; + let __v_329: G = __r_arr[73]; + let __v_330: G = __r_arr[74]; + let __v_331: G = __r_arr[75]; + let __v_332: G = __r_arr[76]; + let __v_333: G = __r_arr[77]; + let __v_334: G = __r_arr[78]; + let __v_335: G = __r_arr[79]; + let __v_336: G = __r_arr[80]; + let __v_337: G = __r_arr[81]; + let __v_338: G = __r_arr[82]; + let __v_339: G = __r_arr[83]; + let __v_340: G = __r_arr[84]; + let __v_341: G = __r_arr[85]; + let __v_342: G = __r_arr[86]; + let __v_343: G = __r_arr[87]; + let __v_344: G = __r_arr[88]; + let __v_345: G = __r_arr[89]; + let __v_346: G = __r_arr[90]; + let __v_347: G = __r_arr[91]; + let __v_348: G = __r_arr[92]; + let __v_349: G = __r_arr[93]; + let __v_350: G = __r_arr[94]; + let __v_351: G = __r_arr[95]; + let __v_352: G = __r_arr[96]; + let __v_353: G = __r_arr[97]; + let __v_354: G = __r_arr[98]; + let __v_355: G = __r_arr[99]; + let __v_356: G = __r_arr[100]; + let __v_357: G = __r_arr[101]; + let __v_358: G = __r_arr[102]; + let __v_359: G = __r_arr[103]; + let __v_360: G = __r_arr[104]; + let __v_361: G = __r_arr[105]; + let __v_362: G = __r_arr[106]; + let __v_363: G = __r_arr[107]; + let __v_364: G = __r_arr[108]; + let __v_365: G = __r_arr[109]; + let __v_366: G = __r_arr[110]; + let __v_367: G = __r_arr[111]; + let __v_368: G = __r_arr[112]; + let __v_369: G = __r_arr[113]; + let __v_370: G = __r_arr[114]; + let __v_371: G = __r_arr[115]; + let __v_372: G = __r_arr[116]; + let __v_373: G = __r_arr[117]; + let __v_374: G = __r_arr[118]; + let __v_375: G = __r_arr[119]; + let __v_376: G = __r_arr[120]; + let __v_377: G = __r_arr[121]; + let __v_378: G = __r_arr[122]; + let __v_379: G = __r_arr[123]; + let __v_380: G = __r_arr[124]; + let __v_381: G = __r_arr[125]; + let __v_382: G = __r_arr[126]; + let __v_383: G = __r_arr[127]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_256, __v_257, __v_258, __v_259, __v_260, __v_261, __v_262, __v_263, __v_264, __v_265, __v_266, __v_267, __v_268, __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, __v_301, __v_302, __v_303, __v_304, __v_305, __v_306, __v_307, __v_308, __v_309, __v_310, __v_311, __v_312, __v_313, __v_314, __v_315, __v_316, __v_317, __v_318, __v_319, __v_328, __v_329, __v_330, __v_331, __v_344, __v_345, __v_346, __v_347, __v_332, __v_333, __v_334, __v_335, __v_360, __v_361, __v_362, __v_363, __v_348, __v_349, __v_350, __v_351, __v_320, __v_321, __v_322, __v_323, __v_336, __v_337, __v_338, __v_339, __v_372, __v_373, __v_374, __v_375, __v_324, __v_325, __v_326, __v_327, __v_364, __v_365, __v_366, __v_367, __v_368, __v_369, __v_370, __v_371, __v_340, __v_341, __v_342, __v_343, __v_356, __v_357, __v_358, __v_359, __v_376, __v_377, __v_378, __v_379, __v_380, __v_381, __v_382, __v_383, __v_352, __v_353, __v_354, __v_355]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_384: G = __r_arr[0]; + let __v_385: G = __r_arr[1]; + let __v_386: G = __r_arr[2]; + let __v_387: G = __r_arr[3]; + let __v_388: G = __r_arr[4]; + let __v_389: G = __r_arr[5]; + let __v_390: G = __r_arr[6]; + let __v_391: G = __r_arr[7]; + let __v_392: G = __r_arr[8]; + let __v_393: G = __r_arr[9]; + let __v_394: G = __r_arr[10]; + let __v_395: G = __r_arr[11]; + let __v_396: G = __r_arr[12]; + let __v_397: G = __r_arr[13]; + let __v_398: G = __r_arr[14]; + let __v_399: G = __r_arr[15]; + let __v_400: G = __r_arr[16]; + let __v_401: G = __r_arr[17]; + let __v_402: G = __r_arr[18]; + let __v_403: G = __r_arr[19]; + let __v_404: G = __r_arr[20]; + let __v_405: G = __r_arr[21]; + let __v_406: G = __r_arr[22]; + let __v_407: G = __r_arr[23]; + let __v_408: G = __r_arr[24]; + let __v_409: G = __r_arr[25]; + let __v_410: G = __r_arr[26]; + let __v_411: G = __r_arr[27]; + let __v_412: G = __r_arr[28]; + let __v_413: G = __r_arr[29]; + let __v_414: G = __r_arr[30]; + let __v_415: G = __r_arr[31]; + let __v_416: G = __r_arr[32]; + let __v_417: G = __r_arr[33]; + let __v_418: G = __r_arr[34]; + let __v_419: G = __r_arr[35]; + let __v_420: G = __r_arr[36]; + let __v_421: G = __r_arr[37]; + let __v_422: G = __r_arr[38]; + let __v_423: G = __r_arr[39]; + let __v_424: G = __r_arr[40]; + let __v_425: G = __r_arr[41]; + let __v_426: G = __r_arr[42]; + let __v_427: G = __r_arr[43]; + let __v_428: G = __r_arr[44]; + let __v_429: G = __r_arr[45]; + let __v_430: G = __r_arr[46]; + let __v_431: G = __r_arr[47]; + let __v_432: G = __r_arr[48]; + let __v_433: G = __r_arr[49]; + let __v_434: G = __r_arr[50]; + let __v_435: G = __r_arr[51]; + let __v_436: G = __r_arr[52]; + let __v_437: G = __r_arr[53]; + let __v_438: G = __r_arr[54]; + let __v_439: G = __r_arr[55]; + let __v_440: G = __r_arr[56]; + let __v_441: G = __r_arr[57]; + let __v_442: G = __r_arr[58]; + let __v_443: G = __r_arr[59]; + let __v_444: G = __r_arr[60]; + let __v_445: G = __r_arr[61]; + let __v_446: G = __r_arr[62]; + let __v_447: G = __r_arr[63]; + let __v_448: G = __r_arr[64]; + let __v_449: G = __r_arr[65]; + let __v_450: G = __r_arr[66]; + let __v_451: G = __r_arr[67]; + let __v_452: G = __r_arr[68]; + let __v_453: G = __r_arr[69]; + let __v_454: G = __r_arr[70]; + let __v_455: G = __r_arr[71]; + let __v_456: G = __r_arr[72]; + let __v_457: G = __r_arr[73]; + let __v_458: G = __r_arr[74]; + let __v_459: G = __r_arr[75]; + let __v_460: G = __r_arr[76]; + let __v_461: G = __r_arr[77]; + let __v_462: G = __r_arr[78]; + let __v_463: G = __r_arr[79]; + let __v_464: G = __r_arr[80]; + let __v_465: G = __r_arr[81]; + let __v_466: G = __r_arr[82]; + let __v_467: G = __r_arr[83]; + let __v_468: G = __r_arr[84]; + let __v_469: G = __r_arr[85]; + let __v_470: G = __r_arr[86]; + let __v_471: G = __r_arr[87]; + let __v_472: G = __r_arr[88]; + let __v_473: G = __r_arr[89]; + let __v_474: G = __r_arr[90]; + let __v_475: G = __r_arr[91]; + let __v_476: G = __r_arr[92]; + let __v_477: G = __r_arr[93]; + let __v_478: G = __r_arr[94]; + let __v_479: G = __r_arr[95]; + let __v_480: G = __r_arr[96]; + let __v_481: G = __r_arr[97]; + let __v_482: G = __r_arr[98]; + let __v_483: G = __r_arr[99]; + let __v_484: G = __r_arr[100]; + let __v_485: G = __r_arr[101]; + let __v_486: G = __r_arr[102]; + let __v_487: G = __r_arr[103]; + let __v_488: G = __r_arr[104]; + let __v_489: G = __r_arr[105]; + let __v_490: G = __r_arr[106]; + let __v_491: G = __r_arr[107]; + let __v_492: G = __r_arr[108]; + let __v_493: G = __r_arr[109]; + let __v_494: G = __r_arr[110]; + let __v_495: G = __r_arr[111]; + let __v_496: G = __r_arr[112]; + let __v_497: G = __r_arr[113]; + let __v_498: G = __r_arr[114]; + let __v_499: G = __r_arr[115]; + let __v_500: G = __r_arr[116]; + let __v_501: G = __r_arr[117]; + let __v_502: G = __r_arr[118]; + let __v_503: G = __r_arr[119]; + let __v_504: G = __r_arr[120]; + let __v_505: G = __r_arr[121]; + let __v_506: G = __r_arr[122]; + let __v_507: G = __r_arr[123]; + let __v_508: G = __r_arr[124]; + let __v_509: G = __r_arr[125]; + let __v_510: G = __r_arr[126]; + let __v_511: G = __r_arr[127]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_384, __v_385, __v_386, __v_387, __v_388, __v_389, __v_390, __v_391, __v_392, __v_393, __v_394, __v_395, __v_396, __v_397, __v_398, __v_399, __v_400, __v_401, __v_402, __v_403, __v_404, __v_405, __v_406, __v_407, __v_408, __v_409, __v_410, __v_411, __v_412, __v_413, __v_414, __v_415, __v_416, __v_417, __v_418, __v_419, __v_420, __v_421, __v_422, __v_423, __v_424, __v_425, __v_426, __v_427, __v_428, __v_429, __v_430, __v_431, __v_432, __v_433, __v_434, __v_435, __v_436, __v_437, __v_438, __v_439, __v_440, __v_441, __v_442, __v_443, __v_444, __v_445, __v_446, __v_447, __v_456, __v_457, __v_458, __v_459, __v_472, __v_473, __v_474, __v_475, __v_460, __v_461, __v_462, __v_463, __v_488, __v_489, __v_490, __v_491, __v_476, __v_477, __v_478, __v_479, __v_448, __v_449, __v_450, __v_451, __v_464, __v_465, __v_466, __v_467, __v_500, __v_501, __v_502, __v_503, __v_452, __v_453, __v_454, __v_455, __v_492, __v_493, __v_494, __v_495, __v_496, __v_497, __v_498, __v_499, __v_468, __v_469, __v_470, __v_471, __v_484, __v_485, __v_486, __v_487, __v_504, __v_505, __v_506, __v_507, __v_508, __v_509, __v_510, __v_511, __v_480, __v_481, __v_482, __v_483]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_512: G = __r_arr[0]; + let __v_513: G = __r_arr[1]; + let __v_514: G = __r_arr[2]; + let __v_515: G = __r_arr[3]; + let __v_516: G = __r_arr[4]; + let __v_517: G = __r_arr[5]; + let __v_518: G = __r_arr[6]; + let __v_519: G = __r_arr[7]; + let __v_520: G = __r_arr[8]; + let __v_521: G = __r_arr[9]; + let __v_522: G = __r_arr[10]; + let __v_523: G = __r_arr[11]; + let __v_524: G = __r_arr[12]; + let __v_525: G = __r_arr[13]; + let __v_526: G = __r_arr[14]; + let __v_527: G = __r_arr[15]; + let __v_528: G = __r_arr[16]; + let __v_529: G = __r_arr[17]; + let __v_530: G = __r_arr[18]; + let __v_531: G = __r_arr[19]; + let __v_532: G = __r_arr[20]; + let __v_533: G = __r_arr[21]; + let __v_534: G = __r_arr[22]; + let __v_535: G = __r_arr[23]; + let __v_536: G = __r_arr[24]; + let __v_537: G = __r_arr[25]; + let __v_538: G = __r_arr[26]; + let __v_539: G = __r_arr[27]; + let __v_540: G = __r_arr[28]; + let __v_541: G = __r_arr[29]; + let __v_542: G = __r_arr[30]; + let __v_543: G = __r_arr[31]; + let __v_544: G = __r_arr[32]; + let __v_545: G = __r_arr[33]; + let __v_546: G = __r_arr[34]; + let __v_547: G = __r_arr[35]; + let __v_548: G = __r_arr[36]; + let __v_549: G = __r_arr[37]; + let __v_550: G = __r_arr[38]; + let __v_551: G = __r_arr[39]; + let __v_552: G = __r_arr[40]; + let __v_553: G = __r_arr[41]; + let __v_554: G = __r_arr[42]; + let __v_555: G = __r_arr[43]; + let __v_556: G = __r_arr[44]; + let __v_557: G = __r_arr[45]; + let __v_558: G = __r_arr[46]; + let __v_559: G = __r_arr[47]; + let __v_560: G = __r_arr[48]; + let __v_561: G = __r_arr[49]; + let __v_562: G = __r_arr[50]; + let __v_563: G = __r_arr[51]; + let __v_564: G = __r_arr[52]; + let __v_565: G = __r_arr[53]; + let __v_566: G = __r_arr[54]; + let __v_567: G = __r_arr[55]; + let __v_568: G = __r_arr[56]; + let __v_569: G = __r_arr[57]; + let __v_570: G = __r_arr[58]; + let __v_571: G = __r_arr[59]; + let __v_572: G = __r_arr[60]; + let __v_573: G = __r_arr[61]; + let __v_574: G = __r_arr[62]; + let __v_575: G = __r_arr[63]; + let __v_576: G = __r_arr[64]; + let __v_577: G = __r_arr[65]; + let __v_578: G = __r_arr[66]; + let __v_579: G = __r_arr[67]; + let __v_580: G = __r_arr[68]; + let __v_581: G = __r_arr[69]; + let __v_582: G = __r_arr[70]; + let __v_583: G = __r_arr[71]; + let __v_584: G = __r_arr[72]; + let __v_585: G = __r_arr[73]; + let __v_586: G = __r_arr[74]; + let __v_587: G = __r_arr[75]; + let __v_588: G = __r_arr[76]; + let __v_589: G = __r_arr[77]; + let __v_590: G = __r_arr[78]; + let __v_591: G = __r_arr[79]; + let __v_592: G = __r_arr[80]; + let __v_593: G = __r_arr[81]; + let __v_594: G = __r_arr[82]; + let __v_595: G = __r_arr[83]; + let __v_596: G = __r_arr[84]; + let __v_597: G = __r_arr[85]; + let __v_598: G = __r_arr[86]; + let __v_599: G = __r_arr[87]; + let __v_600: G = __r_arr[88]; + let __v_601: G = __r_arr[89]; + let __v_602: G = __r_arr[90]; + let __v_603: G = __r_arr[91]; + let __v_604: G = __r_arr[92]; + let __v_605: G = __r_arr[93]; + let __v_606: G = __r_arr[94]; + let __v_607: G = __r_arr[95]; + let __v_608: G = __r_arr[96]; + let __v_609: G = __r_arr[97]; + let __v_610: G = __r_arr[98]; + let __v_611: G = __r_arr[99]; + let __v_612: G = __r_arr[100]; + let __v_613: G = __r_arr[101]; + let __v_614: G = __r_arr[102]; + let __v_615: G = __r_arr[103]; + let __v_616: G = __r_arr[104]; + let __v_617: G = __r_arr[105]; + let __v_618: G = __r_arr[106]; + let __v_619: G = __r_arr[107]; + let __v_620: G = __r_arr[108]; + let __v_621: G = __r_arr[109]; + let __v_622: G = __r_arr[110]; + let __v_623: G = __r_arr[111]; + let __v_624: G = __r_arr[112]; + let __v_625: G = __r_arr[113]; + let __v_626: G = __r_arr[114]; + let __v_627: G = __r_arr[115]; + let __v_628: G = __r_arr[116]; + let __v_629: G = __r_arr[117]; + let __v_630: G = __r_arr[118]; + let __v_631: G = __r_arr[119]; + let __v_632: G = __r_arr[120]; + let __v_633: G = __r_arr[121]; + let __v_634: G = __r_arr[122]; + let __v_635: G = __r_arr[123]; + let __v_636: G = __r_arr[124]; + let __v_637: G = __r_arr[125]; + let __v_638: G = __r_arr[126]; + let __v_639: G = __r_arr[127]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_512, __v_513, __v_514, __v_515, __v_516, __v_517, __v_518, __v_519, __v_520, __v_521, __v_522, __v_523, __v_524, __v_525, __v_526, __v_527, __v_528, __v_529, __v_530, __v_531, __v_532, __v_533, __v_534, __v_535, __v_536, __v_537, __v_538, __v_539, __v_540, __v_541, __v_542, __v_543, __v_544, __v_545, __v_546, __v_547, __v_548, __v_549, __v_550, __v_551, __v_552, __v_553, __v_554, __v_555, __v_556, __v_557, __v_558, __v_559, __v_560, __v_561, __v_562, __v_563, __v_564, __v_565, __v_566, __v_567, __v_568, __v_569, __v_570, __v_571, __v_572, __v_573, __v_574, __v_575, __v_584, __v_585, __v_586, __v_587, __v_600, __v_601, __v_602, __v_603, __v_588, __v_589, __v_590, __v_591, __v_616, __v_617, __v_618, __v_619, __v_604, __v_605, __v_606, __v_607, __v_576, __v_577, __v_578, __v_579, __v_592, __v_593, __v_594, __v_595, __v_628, __v_629, __v_630, __v_631, __v_580, __v_581, __v_582, __v_583, __v_620, __v_621, __v_622, __v_623, __v_624, __v_625, __v_626, __v_627, __v_596, __v_597, __v_598, __v_599, __v_612, __v_613, __v_614, __v_615, __v_632, __v_633, __v_634, __v_635, __v_636, __v_637, __v_638, __v_639, __v_608, __v_609, __v_610, __v_611]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_640: G = __r_arr[0]; + let __v_641: G = __r_arr[1]; + let __v_642: G = __r_arr[2]; + let __v_643: G = __r_arr[3]; + let __v_644: G = __r_arr[4]; + let __v_645: G = __r_arr[5]; + let __v_646: G = __r_arr[6]; + let __v_647: G = __r_arr[7]; + let __v_648: G = __r_arr[8]; + let __v_649: G = __r_arr[9]; + let __v_650: G = __r_arr[10]; + let __v_651: G = __r_arr[11]; + let __v_652: G = __r_arr[12]; + let __v_653: G = __r_arr[13]; + let __v_654: G = __r_arr[14]; + let __v_655: G = __r_arr[15]; + let __v_656: G = __r_arr[16]; + let __v_657: G = __r_arr[17]; + let __v_658: G = __r_arr[18]; + let __v_659: G = __r_arr[19]; + let __v_660: G = __r_arr[20]; + let __v_661: G = __r_arr[21]; + let __v_662: G = __r_arr[22]; + let __v_663: G = __r_arr[23]; + let __v_664: G = __r_arr[24]; + let __v_665: G = __r_arr[25]; + let __v_666: G = __r_arr[26]; + let __v_667: G = __r_arr[27]; + let __v_668: G = __r_arr[28]; + let __v_669: G = __r_arr[29]; + let __v_670: G = __r_arr[30]; + let __v_671: G = __r_arr[31]; + let __v_672: G = __r_arr[32]; + let __v_673: G = __r_arr[33]; + let __v_674: G = __r_arr[34]; + let __v_675: G = __r_arr[35]; + let __v_676: G = __r_arr[36]; + let __v_677: G = __r_arr[37]; + let __v_678: G = __r_arr[38]; + let __v_679: G = __r_arr[39]; + let __v_680: G = __r_arr[40]; + let __v_681: G = __r_arr[41]; + let __v_682: G = __r_arr[42]; + let __v_683: G = __r_arr[43]; + let __v_684: G = __r_arr[44]; + let __v_685: G = __r_arr[45]; + let __v_686: G = __r_arr[46]; + let __v_687: G = __r_arr[47]; + let __v_688: G = __r_arr[48]; + let __v_689: G = __r_arr[49]; + let __v_690: G = __r_arr[50]; + let __v_691: G = __r_arr[51]; + let __v_692: G = __r_arr[52]; + let __v_693: G = __r_arr[53]; + let __v_694: G = __r_arr[54]; + let __v_695: G = __r_arr[55]; + let __v_696: G = __r_arr[56]; + let __v_697: G = __r_arr[57]; + let __v_698: G = __r_arr[58]; + let __v_699: G = __r_arr[59]; + let __v_700: G = __r_arr[60]; + let __v_701: G = __r_arr[61]; + let __v_702: G = __r_arr[62]; + let __v_703: G = __r_arr[63]; + let __v_704: G = __r_arr[64]; + let __v_705: G = __r_arr[65]; + let __v_706: G = __r_arr[66]; + let __v_707: G = __r_arr[67]; + let __v_708: G = __r_arr[68]; + let __v_709: G = __r_arr[69]; + let __v_710: G = __r_arr[70]; + let __v_711: G = __r_arr[71]; + let __v_712: G = __r_arr[72]; + let __v_713: G = __r_arr[73]; + let __v_714: G = __r_arr[74]; + let __v_715: G = __r_arr[75]; + let __v_716: G = __r_arr[76]; + let __v_717: G = __r_arr[77]; + let __v_718: G = __r_arr[78]; + let __v_719: G = __r_arr[79]; + let __v_720: G = __r_arr[80]; + let __v_721: G = __r_arr[81]; + let __v_722: G = __r_arr[82]; + let __v_723: G = __r_arr[83]; + let __v_724: G = __r_arr[84]; + let __v_725: G = __r_arr[85]; + let __v_726: G = __r_arr[86]; + let __v_727: G = __r_arr[87]; + let __v_728: G = __r_arr[88]; + let __v_729: G = __r_arr[89]; + let __v_730: G = __r_arr[90]; + let __v_731: G = __r_arr[91]; + let __v_732: G = __r_arr[92]; + let __v_733: G = __r_arr[93]; + let __v_734: G = __r_arr[94]; + let __v_735: G = __r_arr[95]; + let __v_736: G = __r_arr[96]; + let __v_737: G = __r_arr[97]; + let __v_738: G = __r_arr[98]; + let __v_739: G = __r_arr[99]; + let __v_740: G = __r_arr[100]; + let __v_741: G = __r_arr[101]; + let __v_742: G = __r_arr[102]; + let __v_743: G = __r_arr[103]; + let __v_744: G = __r_arr[104]; + let __v_745: G = __r_arr[105]; + let __v_746: G = __r_arr[106]; + let __v_747: G = __r_arr[107]; + let __v_748: G = __r_arr[108]; + let __v_749: G = __r_arr[109]; + let __v_750: G = __r_arr[110]; + let __v_751: G = __r_arr[111]; + let __v_752: G = __r_arr[112]; + let __v_753: G = __r_arr[113]; + let __v_754: G = __r_arr[114]; + let __v_755: G = __r_arr[115]; + let __v_756: G = __r_arr[116]; + let __v_757: G = __r_arr[117]; + let __v_758: G = __r_arr[118]; + let __v_759: G = __r_arr[119]; + let __v_760: G = __r_arr[120]; + let __v_761: G = __r_arr[121]; + let __v_762: G = __r_arr[122]; + let __v_763: G = __r_arr[123]; + let __v_764: G = __r_arr[124]; + let __v_765: G = __r_arr[125]; + let __v_766: G = __r_arr[126]; + let __v_767: G = __r_arr[127]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_640, __v_641, __v_642, __v_643, __v_644, __v_645, __v_646, __v_647, __v_648, __v_649, __v_650, __v_651, __v_652, __v_653, __v_654, __v_655, __v_656, __v_657, __v_658, __v_659, __v_660, __v_661, __v_662, __v_663, __v_664, __v_665, __v_666, __v_667, __v_668, __v_669, __v_670, __v_671, __v_672, __v_673, __v_674, __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_712, __v_713, __v_714, __v_715, __v_728, __v_729, __v_730, __v_731, __v_716, __v_717, __v_718, __v_719, __v_744, __v_745, __v_746, __v_747, __v_732, __v_733, __v_734, __v_735, __v_704, __v_705, __v_706, __v_707, __v_720, __v_721, __v_722, __v_723, __v_756, __v_757, __v_758, __v_759, __v_708, __v_709, __v_710, __v_711, __v_748, __v_749, __v_750, __v_751, __v_752, __v_753, __v_754, __v_755, __v_724, __v_725, __v_726, __v_727, __v_740, __v_741, __v_742, __v_743, __v_760, __v_761, __v_762, __v_763, __v_764, __v_765, __v_766, __v_767, __v_736, __v_737, __v_738, __v_739]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_768: G = __r_arr[0]; + let __v_769: G = __r_arr[1]; + let __v_770: G = __r_arr[2]; + let __v_771: G = __r_arr[3]; + let __v_772: G = __r_arr[4]; + let __v_773: G = __r_arr[5]; + let __v_774: G = __r_arr[6]; + let __v_775: G = __r_arr[7]; + let __v_776: G = __r_arr[8]; + let __v_777: G = __r_arr[9]; + let __v_778: G = __r_arr[10]; + let __v_779: G = __r_arr[11]; + let __v_780: G = __r_arr[12]; + let __v_781: G = __r_arr[13]; + let __v_782: G = __r_arr[14]; + let __v_783: G = __r_arr[15]; + let __v_784: G = __r_arr[16]; + let __v_785: G = __r_arr[17]; + let __v_786: G = __r_arr[18]; + let __v_787: G = __r_arr[19]; + let __v_788: G = __r_arr[20]; + let __v_789: G = __r_arr[21]; + let __v_790: G = __r_arr[22]; + let __v_791: G = __r_arr[23]; + let __v_792: G = __r_arr[24]; + let __v_793: G = __r_arr[25]; + let __v_794: G = __r_arr[26]; + let __v_795: G = __r_arr[27]; + let __v_796: G = __r_arr[28]; + let __v_797: G = __r_arr[29]; + let __v_798: G = __r_arr[30]; + let __v_799: G = __r_arr[31]; + let __v_800: G = __r_arr[32]; + let __v_801: G = __r_arr[33]; + let __v_802: G = __r_arr[34]; + let __v_803: G = __r_arr[35]; + let __v_804: G = __r_arr[36]; + let __v_805: G = __r_arr[37]; + let __v_806: G = __r_arr[38]; + let __v_807: G = __r_arr[39]; + let __v_808: G = __r_arr[40]; + let __v_809: G = __r_arr[41]; + let __v_810: G = __r_arr[42]; + let __v_811: G = __r_arr[43]; + let __v_812: G = __r_arr[44]; + let __v_813: G = __r_arr[45]; + let __v_814: G = __r_arr[46]; + let __v_815: G = __r_arr[47]; + let __v_816: G = __r_arr[48]; + let __v_817: G = __r_arr[49]; + let __v_818: G = __r_arr[50]; + let __v_819: G = __r_arr[51]; + let __v_820: G = __r_arr[52]; + let __v_821: G = __r_arr[53]; + let __v_822: G = __r_arr[54]; + let __v_823: G = __r_arr[55]; + let __v_824: G = __r_arr[56]; + let __v_825: G = __r_arr[57]; + let __v_826: G = __r_arr[58]; + let __v_827: G = __r_arr[59]; + let __v_828: G = __r_arr[60]; + let __v_829: G = __r_arr[61]; + let __v_830: G = __r_arr[62]; + let __v_831: G = __r_arr[63]; + let __v_832: G = __r_arr[64]; + let __v_833: G = __r_arr[65]; + let __v_834: G = __r_arr[66]; + let __v_835: G = __r_arr[67]; + let __v_836: G = __r_arr[68]; + let __v_837: G = __r_arr[69]; + let __v_838: G = __r_arr[70]; + let __v_839: G = __r_arr[71]; + let __v_840: G = __r_arr[72]; + let __v_841: G = __r_arr[73]; + let __v_842: G = __r_arr[74]; + let __v_843: G = __r_arr[75]; + let __v_844: G = __r_arr[76]; + let __v_845: G = __r_arr[77]; + let __v_846: G = __r_arr[78]; + let __v_847: G = __r_arr[79]; + let __v_848: G = __r_arr[80]; + let __v_849: G = __r_arr[81]; + let __v_850: G = __r_arr[82]; + let __v_851: G = __r_arr[83]; + let __v_852: G = __r_arr[84]; + let __v_853: G = __r_arr[85]; + let __v_854: G = __r_arr[86]; + let __v_855: G = __r_arr[87]; + let __v_856: G = __r_arr[88]; + let __v_857: G = __r_arr[89]; + let __v_858: G = __r_arr[90]; + let __v_859: G = __r_arr[91]; + let __v_860: G = __r_arr[92]; + let __v_861: G = __r_arr[93]; + let __v_862: G = __r_arr[94]; + let __v_863: G = __r_arr[95]; + let __v_864: G = __r_arr[96]; + let __v_865: G = __r_arr[97]; + let __v_866: G = __r_arr[98]; + let __v_867: G = __r_arr[99]; + let __v_868: G = __r_arr[100]; + let __v_869: G = __r_arr[101]; + let __v_870: G = __r_arr[102]; + let __v_871: G = __r_arr[103]; + let __v_872: G = __r_arr[104]; + let __v_873: G = __r_arr[105]; + let __v_874: G = __r_arr[106]; + let __v_875: G = __r_arr[107]; + let __v_876: G = __r_arr[108]; + let __v_877: G = __r_arr[109]; + let __v_878: G = __r_arr[110]; + let __v_879: G = __r_arr[111]; + let __v_880: G = __r_arr[112]; + let __v_881: G = __r_arr[113]; + let __v_882: G = __r_arr[114]; + let __v_883: G = __r_arr[115]; + let __v_884: G = __r_arr[116]; + let __v_885: G = __r_arr[117]; + let __v_886: G = __r_arr[118]; + let __v_887: G = __r_arr[119]; + let __v_888: G = __r_arr[120]; + let __v_889: G = __r_arr[121]; + let __v_890: G = __r_arr[122]; + let __v_891: G = __r_arr[123]; + let __v_892: G = __r_arr[124]; + let __v_893: G = __r_arr[125]; + let __v_894: G = __r_arr[126]; + let __v_895: G = __r_arr[127]; + let __r_arr: [G; OUT_29] = { let __args: [G; IN_29] = [__v_768, __v_769, __v_770, __v_771, __v_772, __v_773, __v_774, __v_775, __v_776, __v_777, __v_778, __v_779, __v_780, __v_781, __v_782, __v_783, __v_784, __v_785, __v_786, __v_787, __v_788, __v_789, __v_790, __v_791, __v_792, __v_793, __v_794, __v_795, __v_796, __v_797, __v_798, __v_799, __v_800, __v_801, __v_802, __v_803, __v_804, __v_805, __v_806, __v_807, __v_808, __v_809, __v_810, __v_811, __v_812, __v_813, __v_814, __v_815, __v_816, __v_817, __v_818, __v_819, __v_820, __v_821, __v_822, __v_823, __v_824, __v_825, __v_826, __v_827, __v_828, __v_829, __v_830, __v_831, __v_840, __v_841, __v_842, __v_843, __v_856, __v_857, __v_858, __v_859, __v_844, __v_845, __v_846, __v_847, __v_872, __v_873, __v_874, __v_875, __v_860, __v_861, __v_862, __v_863, __v_832, __v_833, __v_834, __v_835, __v_848, __v_849, __v_850, __v_851, __v_884, __v_885, __v_886, __v_887, __v_836, __v_837, __v_838, __v_839, __v_876, __v_877, __v_878, __v_879, __v_880, __v_881, __v_882, __v_883, __v_852, __v_853, __v_854, __v_855, __v_868, __v_869, __v_870, __v_871, __v_888, __v_889, __v_890, __v_891, __v_892, __v_893, __v_894, __v_895, __v_864, __v_865, __v_866, __v_867]; let __cu = unconstrained; if let Some(result) = record.function_queries[29].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_29] = unsafe { *(result.output.as_ptr() as *const [G; OUT_29]) }; __ret } else { aiur_fn_29(__args, record, io_buffer, __cu)? } }; + let __v_896: G = __r_arr[0]; + let __v_897: G = __r_arr[1]; + let __v_898: G = __r_arr[2]; + let __v_899: G = __r_arr[3]; + let __v_900: G = __r_arr[4]; + let __v_901: G = __r_arr[5]; + let __v_902: G = __r_arr[6]; + let __v_903: G = __r_arr[7]; + let __v_904: G = __r_arr[8]; + let __v_905: G = __r_arr[9]; + let __v_906: G = __r_arr[10]; + let __v_907: G = __r_arr[11]; + let __v_908: G = __r_arr[12]; + let __v_909: G = __r_arr[13]; + let __v_910: G = __r_arr[14]; + let __v_911: G = __r_arr[15]; + let __v_912: G = __r_arr[16]; + let __v_913: G = __r_arr[17]; + let __v_914: G = __r_arr[18]; + let __v_915: G = __r_arr[19]; + let __v_916: G = __r_arr[20]; + let __v_917: G = __r_arr[21]; + let __v_918: G = __r_arr[22]; + let __v_919: G = __r_arr[23]; + let __v_920: G = __r_arr[24]; + let __v_921: G = __r_arr[25]; + let __v_922: G = __r_arr[26]; + let __v_923: G = __r_arr[27]; + let __v_924: G = __r_arr[28]; + let __v_925: G = __r_arr[29]; + let __v_926: G = __r_arr[30]; + let __v_927: G = __r_arr[31]; + let __v_928: G = __r_arr[32]; + let __v_929: G = __r_arr[33]; + let __v_930: G = __r_arr[34]; + let __v_931: G = __r_arr[35]; + let __v_932: G = __r_arr[36]; + let __v_933: G = __r_arr[37]; + let __v_934: G = __r_arr[38]; + let __v_935: G = __r_arr[39]; + let __v_936: G = __r_arr[40]; + let __v_937: G = __r_arr[41]; + let __v_938: G = __r_arr[42]; + let __v_939: G = __r_arr[43]; + let __v_940: G = __r_arr[44]; + let __v_941: G = __r_arr[45]; + let __v_942: G = __r_arr[46]; + let __v_943: G = __r_arr[47]; + let __v_944: G = __r_arr[48]; + let __v_945: G = __r_arr[49]; + let __v_946: G = __r_arr[50]; + let __v_947: G = __r_arr[51]; + let __v_948: G = __r_arr[52]; + let __v_949: G = __r_arr[53]; + let __v_950: G = __r_arr[54]; + let __v_951: G = __r_arr[55]; + let __v_952: G = __r_arr[56]; + let __v_953: G = __r_arr[57]; + let __v_954: G = __r_arr[58]; + let __v_955: G = __r_arr[59]; + let __v_956: G = __r_arr[60]; + let __v_957: G = __r_arr[61]; + let __v_958: G = __r_arr[62]; + let __v_959: G = __r_arr[63]; + let __v_960: G = __r_arr[64]; + let __v_961: G = __r_arr[65]; + let __v_962: G = __r_arr[66]; + let __v_963: G = __r_arr[67]; + let __v_964: G = __r_arr[68]; + let __v_965: G = __r_arr[69]; + let __v_966: G = __r_arr[70]; + let __v_967: G = __r_arr[71]; + let __v_968: G = __r_arr[72]; + let __v_969: G = __r_arr[73]; + let __v_970: G = __r_arr[74]; + let __v_971: G = __r_arr[75]; + let __v_972: G = __r_arr[76]; + let __v_973: G = __r_arr[77]; + let __v_974: G = __r_arr[78]; + let __v_975: G = __r_arr[79]; + let __v_976: G = __r_arr[80]; + let __v_977: G = __r_arr[81]; + let __v_978: G = __r_arr[82]; + let __v_979: G = __r_arr[83]; + let __v_980: G = __r_arr[84]; + let __v_981: G = __r_arr[85]; + let __v_982: G = __r_arr[86]; + let __v_983: G = __r_arr[87]; + let __v_984: G = __r_arr[88]; + let __v_985: G = __r_arr[89]; + let __v_986: G = __r_arr[90]; + let __v_987: G = __r_arr[91]; + let __v_988: G = __r_arr[92]; + let __v_989: G = __r_arr[93]; + let __v_990: G = __r_arr[94]; + let __v_991: G = __r_arr[95]; + let __v_992: G = __r_arr[96]; + let __v_993: G = __r_arr[97]; + let __v_994: G = __r_arr[98]; + let __v_995: G = __r_arr[99]; + let __v_996: G = __r_arr[100]; + let __v_997: G = __r_arr[101]; + let __v_998: G = __r_arr[102]; + let __v_999: G = __r_arr[103]; + let __v_1000: G = __r_arr[104]; + let __v_1001: G = __r_arr[105]; + let __v_1002: G = __r_arr[106]; + let __v_1003: G = __r_arr[107]; + let __v_1004: G = __r_arr[108]; + let __v_1005: G = __r_arr[109]; + let __v_1006: G = __r_arr[110]; + let __v_1007: G = __r_arr[111]; + let __v_1008: G = __r_arr[112]; + let __v_1009: G = __r_arr[113]; + let __v_1010: G = __r_arr[114]; + let __v_1011: G = __r_arr[115]; + let __v_1012: G = __r_arr[116]; + let __v_1013: G = __r_arr[117]; + let __v_1014: G = __r_arr[118]; + let __v_1015: G = __r_arr[119]; + let __v_1016: G = __r_arr[120]; + let __v_1017: G = __r_arr[121]; + let __v_1018: G = __r_arr[122]; + let __v_1019: G = __r_arr[123]; + let __v_1020: G = __r_arr[124]; + let __v_1021: G = __r_arr[125]; + let __v_1022: G = __r_arr[126]; + let __v_1023: G = __r_arr[127]; + let __v_1024: G = if unconstrained { Bytes2::xor(&__v_896, &__v_928) } else { bytes2_xor_value(__v_896, __v_928, record) }; + let __v_1025: G = if unconstrained { Bytes2::xor(&__v_897, &__v_929) } else { bytes2_xor_value(__v_897, __v_929, record) }; + let __v_1026: G = if unconstrained { Bytes2::xor(&__v_898, &__v_930) } else { bytes2_xor_value(__v_898, __v_930, record) }; + let __v_1027: G = if unconstrained { Bytes2::xor(&__v_899, &__v_931) } else { bytes2_xor_value(__v_899, __v_931, record) }; + let __v_1028: G = if unconstrained { Bytes2::xor(&__v_900, &__v_932) } else { bytes2_xor_value(__v_900, __v_932, record) }; + let __v_1029: G = if unconstrained { Bytes2::xor(&__v_901, &__v_933) } else { bytes2_xor_value(__v_901, __v_933, record) }; + let __v_1030: G = if unconstrained { Bytes2::xor(&__v_902, &__v_934) } else { bytes2_xor_value(__v_902, __v_934, record) }; + let __v_1031: G = if unconstrained { Bytes2::xor(&__v_903, &__v_935) } else { bytes2_xor_value(__v_903, __v_935, record) }; + let __v_1032: G = if unconstrained { Bytes2::xor(&__v_904, &__v_936) } else { bytes2_xor_value(__v_904, __v_936, record) }; + let __v_1033: G = if unconstrained { Bytes2::xor(&__v_905, &__v_937) } else { bytes2_xor_value(__v_905, __v_937, record) }; + let __v_1034: G = if unconstrained { Bytes2::xor(&__v_906, &__v_938) } else { bytes2_xor_value(__v_906, __v_938, record) }; + let __v_1035: G = if unconstrained { Bytes2::xor(&__v_907, &__v_939) } else { bytes2_xor_value(__v_907, __v_939, record) }; + let __v_1036: G = if unconstrained { Bytes2::xor(&__v_908, &__v_940) } else { bytes2_xor_value(__v_908, __v_940, record) }; + let __v_1037: G = if unconstrained { Bytes2::xor(&__v_909, &__v_941) } else { bytes2_xor_value(__v_909, __v_941, record) }; + let __v_1038: G = if unconstrained { Bytes2::xor(&__v_910, &__v_942) } else { bytes2_xor_value(__v_910, __v_942, record) }; + let __v_1039: G = if unconstrained { Bytes2::xor(&__v_911, &__v_943) } else { bytes2_xor_value(__v_911, __v_943, record) }; + let __v_1040: G = if unconstrained { Bytes2::xor(&__v_912, &__v_944) } else { bytes2_xor_value(__v_912, __v_944, record) }; + let __v_1041: G = if unconstrained { Bytes2::xor(&__v_913, &__v_945) } else { bytes2_xor_value(__v_913, __v_945, record) }; + let __v_1042: G = if unconstrained { Bytes2::xor(&__v_914, &__v_946) } else { bytes2_xor_value(__v_914, __v_946, record) }; + let __v_1043: G = if unconstrained { Bytes2::xor(&__v_915, &__v_947) } else { bytes2_xor_value(__v_915, __v_947, record) }; + let __v_1044: G = if unconstrained { Bytes2::xor(&__v_916, &__v_948) } else { bytes2_xor_value(__v_916, __v_948, record) }; + let __v_1045: G = if unconstrained { Bytes2::xor(&__v_917, &__v_949) } else { bytes2_xor_value(__v_917, __v_949, record) }; + let __v_1046: G = if unconstrained { Bytes2::xor(&__v_918, &__v_950) } else { bytes2_xor_value(__v_918, __v_950, record) }; + let __v_1047: G = if unconstrained { Bytes2::xor(&__v_919, &__v_951) } else { bytes2_xor_value(__v_919, __v_951, record) }; + let __v_1048: G = if unconstrained { Bytes2::xor(&__v_920, &__v_952) } else { bytes2_xor_value(__v_920, __v_952, record) }; + let __v_1049: G = if unconstrained { Bytes2::xor(&__v_921, &__v_953) } else { bytes2_xor_value(__v_921, __v_953, record) }; + let __v_1050: G = if unconstrained { Bytes2::xor(&__v_922, &__v_954) } else { bytes2_xor_value(__v_922, __v_954, record) }; + let __v_1051: G = if unconstrained { Bytes2::xor(&__v_923, &__v_955) } else { bytes2_xor_value(__v_923, __v_955, record) }; + let __v_1052: G = if unconstrained { Bytes2::xor(&__v_924, &__v_956) } else { bytes2_xor_value(__v_924, __v_956, record) }; + let __v_1053: G = if unconstrained { Bytes2::xor(&__v_925, &__v_957) } else { bytes2_xor_value(__v_925, __v_957, record) }; + let __v_1054: G = if unconstrained { Bytes2::xor(&__v_926, &__v_958) } else { bytes2_xor_value(__v_926, __v_958, record) }; + let __v_1055: G = if unconstrained { Bytes2::xor(&__v_927, &__v_959) } else { bytes2_xor_value(__v_927, __v_959, record) }; + let __ret: [G; OUT_30] = [__v_1024, __v_1025, __v_1026, __v_1027, __v_1028, __v_1029, __v_1030, __v_1031, __v_1032, __v_1033, __v_1034, __v_1035, __v_1036, __v_1037, __v_1038, __v_1039, __v_1040, __v_1041, __v_1042, __v_1043, __v_1044, __v_1045, __v_1046, __v_1047, __v_1048, __v_1049, __v_1050, __v_1051, __v_1052, __v_1053, __v_1054, __v_1055]; + record.function_queries[30].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_31: usize = 0; +const IN_31: usize = 0; +const OUT_31: usize = 22; +fn aiur_fn_31( + inp: [G; IN_31], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_31], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(5); + let __v_1: G = G::from_u64(42); + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_1, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __v_6: G = __r_arr[2]; + let __v_7: G = __r_arr[3]; + let __v_8: G = __r_arr[4]; + let __v_9: G = __r_arr[5]; + let __v_10: G = G::from_u64(5); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_10, __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 !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 = G::from_u64(10); + let __v_13: G = G::from_u64(100); + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_12, __v_13, __v_14, __v_15, __v_15, __v_15, __v_15, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __v_19: G = __r_arr[3]; + let __v_20: G = __r_arr[4]; + let __v_21: G = __r_arr[5]; + let __v_22: G = G::from_u64(20); + let __v_23: G = G::from_u64(200); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __v_26: G = __r_arr[2]; + let __v_27: G = __r_arr[3]; + let __v_28: G = __r_arr[4]; + let __v_29: G = __r_arr[5]; + let __v_30: G = G::from_u64(5); + let __v_31: G = G::from_u64(50); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_30, __v_31, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + let __v_34: G = __r_arr[2]; + let __v_35: G = __r_arr[3]; + let __v_36: G = __r_arr[4]; + let __v_37: G = __r_arr[5]; + let __v_38: G = G::from_u64(5); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_38, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = G::from_u64(10); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_40, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = G::from_u64(20); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_42, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = G::from_u64(10); + let __v_45: G = G::from_u64(100); + let __v_46: G = G::from_u64(1); + let __v_47: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_44, __v_45, __v_46, __v_47, __v_47, __v_47, __v_47, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __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 = G::from_u64(10); + let __v_55: G = G::from_u64(999); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_54, __v_55, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __v_58: G = __r_arr[2]; + let __v_59: G = __r_arr[3]; + let __v_60: G = __r_arr[4]; + let __v_61: G = __r_arr[5]; + let __v_62: G = G::from_u64(10); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_62, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __v_64: G = G::from_u64(1); + let __v_65: G = G::from_u64(10); + let __v_66: G = G::from_u64(1); + let __v_67: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_64, __v_65, __v_66, __v_67, __v_67, __v_67, __v_67, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + let __v_69: G = __r_arr[1]; + let __v_70: G = __r_arr[2]; + let __v_71: G = __r_arr[3]; + let __v_72: G = __r_arr[4]; + let __v_73: G = __r_arr[5]; + let __v_74: G = G::from_u64(2); + let __v_75: G = G::from_u64(20); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_74, __v_75, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __v_77: G = __r_arr[1]; + let __v_78: G = __r_arr[2]; + let __v_79: G = __r_arr[3]; + let __v_80: G = __r_arr[4]; + let __v_81: G = __r_arr[5]; + let __v_82: G = G::from_u64(3); + let __v_83: G = G::from_u64(30); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_82, __v_83, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __v_85: G = __r_arr[1]; + let __v_86: G = __r_arr[2]; + let __v_87: G = __r_arr[3]; + let __v_88: G = __r_arr[4]; + let __v_89: G = __r_arr[5]; + let __v_90: G = G::from_u64(4); + let __v_91: G = G::from_u64(40); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_90, __v_91, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_92: G = __r_arr[0]; + let __v_93: G = __r_arr[1]; + let __v_94: G = __r_arr[2]; + let __v_95: G = __r_arr[3]; + let __v_96: G = __r_arr[4]; + let __v_97: G = __r_arr[5]; + let __v_98: G = G::from_u64(5); + let __v_99: G = G::from_u64(50); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_98, __v_99, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_100: G = __r_arr[0]; + let __v_101: G = __r_arr[1]; + let __v_102: G = __r_arr[2]; + let __v_103: G = __r_arr[3]; + let __v_104: G = __r_arr[4]; + let __v_105: G = __r_arr[5]; + let __v_106: G = G::from_u64(1); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_106, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_107: G = __r_arr[0]; + let __v_108: G = G::from_u64(2); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_108, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __v_110: G = G::from_u64(3); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_110, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_111: G = __r_arr[0]; + let __v_112: G = G::from_u64(4); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_112, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_113: G = __r_arr[0]; + let __v_114: G = G::from_u64(5); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_114, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_115: G = __r_arr[0]; + let __v_116: G = G::from_u64(5); + let __v_117: G = G::from_u64(50); + let __v_118: G = G::from_u64(1); + let __v_119: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_116, __v_117, __v_118, __v_119, __v_119, __v_119, __v_119, __v_119]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_120: G = __r_arr[0]; + let __v_121: G = __r_arr[1]; + let __v_122: G = __r_arr[2]; + let __v_123: G = __r_arr[3]; + let __v_124: G = __r_arr[4]; + let __v_125: G = __r_arr[5]; + let __v_126: G = G::from_u64(4); + let __v_127: G = G::from_u64(40); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_126, __v_127, __v_120, __v_121, __v_122, __v_123, __v_124, __v_125]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_128: G = __r_arr[0]; + let __v_129: G = __r_arr[1]; + let __v_130: G = __r_arr[2]; + let __v_131: G = __r_arr[3]; + let __v_132: G = __r_arr[4]; + let __v_133: G = __r_arr[5]; + let __v_134: G = G::from_u64(3); + let __v_135: G = G::from_u64(30); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_134, __v_135, __v_128, __v_129, __v_130, __v_131, __v_132, __v_133]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_136: G = __r_arr[0]; + let __v_137: G = __r_arr[1]; + let __v_138: G = __r_arr[2]; + let __v_139: G = __r_arr[3]; + let __v_140: G = __r_arr[4]; + let __v_141: G = __r_arr[5]; + let __v_142: G = G::from_u64(2); + let __v_143: G = G::from_u64(20); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_142, __v_143, __v_136, __v_137, __v_138, __v_139, __v_140, __v_141]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_144: G = __r_arr[0]; + let __v_145: G = __r_arr[1]; + let __v_146: G = __r_arr[2]; + let __v_147: G = __r_arr[3]; + let __v_148: G = __r_arr[4]; + let __v_149: G = __r_arr[5]; + let __v_150: G = G::from_u64(1); + let __v_151: G = G::from_u64(10); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_150, __v_151, __v_144, __v_145, __v_146, __v_147, __v_148, __v_149]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_152: G = __r_arr[0]; + let __v_153: G = __r_arr[1]; + let __v_154: G = __r_arr[2]; + let __v_155: G = __r_arr[3]; + let __v_156: G = __r_arr[4]; + let __v_157: G = __r_arr[5]; + let __v_158: G = G::from_u64(1); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_158, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_159: G = __r_arr[0]; + let __v_160: G = G::from_u64(2); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_160, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_161: G = __r_arr[0]; + let __v_162: G = G::from_u64(3); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_162, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_163: G = __r_arr[0]; + let __v_164: G = G::from_u64(4); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_164, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_165: G = __r_arr[0]; + let __v_166: G = G::from_u64(5); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_166, __v_152, __v_153, __v_154, __v_155, __v_156, __v_157]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_167: G = __r_arr[0]; + let __v_168: G = G::from_u64(50); + let __v_169: G = G::from_u64(500); + let __v_170: G = G::from_u64(1); + let __v_171: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_168, __v_169, __v_170, __v_171, __v_171, __v_171, __v_171, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __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 = G::from_u64(30); + let __v_179: G = G::from_u64(300); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_178, __v_179, __v_172, __v_173, __v_174, __v_175, __v_176, __v_177]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_180: G = __r_arr[0]; + let __v_181: G = __r_arr[1]; + let __v_182: G = __r_arr[2]; + let __v_183: G = __r_arr[3]; + let __v_184: G = __r_arr[4]; + let __v_185: G = __r_arr[5]; + let __v_186: G = G::from_u64(70); + let __v_187: G = G::from_u64(700); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_186, __v_187, __v_180, __v_181, __v_182, __v_183, __v_184, __v_185]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_188: G = __r_arr[0]; + let __v_189: G = __r_arr[1]; + let __v_190: G = __r_arr[2]; + let __v_191: G = __r_arr[3]; + let __v_192: G = __r_arr[4]; + let __v_193: G = __r_arr[5]; + let __v_194: G = G::from_u64(20); + let __v_195: G = G::from_u64(200); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_194, __v_195, __v_188, __v_189, __v_190, __v_191, __v_192, __v_193]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_196: G = __r_arr[0]; + let __v_197: G = __r_arr[1]; + let __v_198: G = __r_arr[2]; + let __v_199: G = __r_arr[3]; + let __v_200: G = __r_arr[4]; + let __v_201: G = __r_arr[5]; + let __v_202: G = G::from_u64(40); + let __v_203: G = G::from_u64(400); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_202, __v_203, __v_196, __v_197, __v_198, __v_199, __v_200, __v_201]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_204: G = __r_arr[0]; + let __v_205: G = __r_arr[1]; + let __v_206: G = __r_arr[2]; + let __v_207: G = __r_arr[3]; + let __v_208: G = __r_arr[4]; + let __v_209: G = __r_arr[5]; + let __v_210: G = G::from_u64(60); + let __v_211: G = G::from_u64(600); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_210, __v_211, __v_204, __v_205, __v_206, __v_207, __v_208, __v_209]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_212: G = __r_arr[0]; + let __v_213: G = __r_arr[1]; + let __v_214: G = __r_arr[2]; + let __v_215: G = __r_arr[3]; + let __v_216: G = __r_arr[4]; + let __v_217: G = __r_arr[5]; + let __v_218: G = G::from_u64(80); + let __v_219: G = G::from_u64(800); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_218, __v_219, __v_212, __v_213, __v_214, __v_215, __v_216, __v_217]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_220: G = __r_arr[0]; + let __v_221: G = __r_arr[1]; + let __v_222: G = __r_arr[2]; + let __v_223: G = __r_arr[3]; + let __v_224: G = __r_arr[4]; + let __v_225: G = __r_arr[5]; + let __v_226: G = G::from_u64(20); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_226, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_227: G = __r_arr[0]; + let __v_228: G = G::from_u64(30); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_228, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_229: G = __r_arr[0]; + let __v_230: G = G::from_u64(40); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_230, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_231: G = __r_arr[0]; + let __v_232: G = G::from_u64(50); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_232, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_233: G = __r_arr[0]; + let __v_234: G = G::from_u64(60); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_234, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_235: G = __r_arr[0]; + let __v_236: G = G::from_u64(70); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_236, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_237: G = __r_arr[0]; + let __v_238: G = G::from_u64(80); + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_238, __v_220, __v_221, __v_222, __v_223, __v_224, __v_225]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_239: G = __r_arr[0]; + let __ret: [G; OUT_31] = [__v_11, __v_39, __v_41, __v_43, __v_63, __v_107, __v_109, __v_111, __v_113, __v_115, __v_159, __v_161, __v_163, __v_165, __v_167, __v_227, __v_229, __v_231, __v_233, __v_235, __v_237, __v_239]; + record.function_queries[31].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_32: usize = 19; +const IN_32: usize = 19; +const OUT_32: usize = 1; +fn aiur_fn_32( + inp: [G; IN_32], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_32], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_32] = [__v_20]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_19: G = G::from_u64(1); + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_32] = [__v_20]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __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_37] = { let __args: [G; IN_37] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { 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 __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_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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 __ret: [G; OUT_32] = [__v_30]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __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_37] = { let __args: [G; IN_37] = [__v_9, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { 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 __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_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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 __ret: [G; OUT_32] = [__v_30]; + record.function_queries[32].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_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[32].get_mut(&__args[..]) { 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_38: G = __r_arr[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_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_39: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_40: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_40]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_19: G = G::from_u64(5); + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_32] = [__v_20]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_19: G = G::from_u64(6); + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_32] = [__v_20]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __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[38].get_mut(&__args[..]) { 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_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_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, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_32] = [__v_29]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __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[39].get_mut(&__args[..]) { 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_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_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, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[42].get_mut(&__args[..]) { 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_28: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_32] = [__v_29]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 9u64 => { + 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 !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(9); + 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 !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_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_32] = [__v_29]; + record.function_queries[32].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_32] = { let __args: [G; IN_32] = [__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[32].get_mut(&__args[..]) { 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_74: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_37, __v_38, __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[32].get_mut(&__args[..]) { 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_75: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[32].get_mut(&__args[..]) { 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_76: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_77: G = __r_arr[0]; + let __ret: [G; OUT_32] = [__v_77]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 11u64 => { + let __v_19: G = G::from_u64(11); + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_32] = [__v_20]; + record.function_queries[32].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_33: usize = 10; +const IN_33: usize = 10; +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]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_33] = [__v_9]; + record.function_queries[33].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_33] = { let __args: [G; IN_33] = [__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[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_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_33] = [__v_15]; + record.function_queries[33].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_34: usize = 9; +const IN_34: usize = 9; +const OUT_34: usize = 1; +fn aiur_fn_34( + inp: [G; IN_34], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_34], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__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[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __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) }; + match __v_9.as_canonical_u64() { + 1u64 => { + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_0, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_13]; + record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(128); + let __v_13: G = G::from_u64(1); + 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_33] = { let __args: [G; IN_33] = [__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[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_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_34] = [__v_18]; + record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_12: G = G::from_u64(128); + let __v_13: G = G::from_u64(1); + 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_33] = { let __args: [G; IN_33] = [__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[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_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_34] = [__v_18]; + record.function_queries[34].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +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]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__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[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __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) }; + match __v_10.as_canonical_u64() { + 1u64 => { + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(64); + let __v_14: G = (__v_0 * __v_13); + let __v_15: G = (__v_14 + __v_1); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_35] = [__v_17]; + record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(64); + let __v_14: G = (__v_0 * __v_13); + let __v_15: G = G::from_u64(32); + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_10 - __v_16); + 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_33] = { let __args: [G; IN_33] = [__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[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_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_35] = [__v_22]; + record.function_queries[35].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(64); + let __v_14: G = (__v_0 * __v_13); + let __v_15: G = G::from_u64(32); + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_10 - __v_16); + 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_33] = { let __args: [G; IN_33] = [__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[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_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_35] = [__v_22]; + record.function_queries[35].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_36], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __r_arr: [G; OUT_1] = { let __args: [G; IN_1] = [__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[1].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_1] = unsafe { *(result.output.as_ptr() as *const [G; OUT_1]) }; __ret } else { aiur_fn_1(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __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) }; + match __v_10.as_canonical_u64() { + 1u64 => { + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(16); + let __v_14: G = (__v_0 * __v_13); + let __v_15: G = (__v_14 + __v_1); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_15, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_36] = [__v_17]; + record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(16); + let __v_14: G = (__v_0 * __v_13); + let __v_15: G = G::from_u64(8); + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_10 - __v_16); + 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_33] = { let __args: [G; IN_33] = [__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[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_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]; + record.function_queries[36].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(16); + let __v_14: G = (__v_0 * __v_13); + let __v_15: G = G::from_u64(8); + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_10 - __v_16); + 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_33] = { let __args: [G; IN_33] = [__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[33].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_33] = unsafe { *(result.output.as_ptr() as *const [G; OUT_33]) }; __ret } else { aiur_fn_33(__args, record, io_buffer, __cu)? } }; + let __v_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]; + record.function_queries[36].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 = 1; +fn aiur_fn_37( + inp: [G; IN_37], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_37], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __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_37] = [__v_1]; + record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_37] = { let __args: [G; IN_37] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[37].get_mut(&__args[..]) { 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_12: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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 __ret: [G; OUT_37] = [__v_13]; + record.function_queries[37].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_38: usize = 18; +const IN_38: usize = 18; +const OUT_38: usize = 8; +fn aiur_fn_38( + inp: [G; IN_38], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_38], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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]; + match __v_0.as_canonical_u64() { + 7u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + let __v_28: G = __loaded[10]; + let __v_29: G = __loaded[11]; + let __v_30: G = __loaded[12]; + let __v_31: G = __loaded[13]; + let __v_32: G = __loaded[14]; + let __v_33: G = __loaded[15]; + let __v_34: G = __loaded[16]; + let __v_35: G = __loaded[17]; + let __r_arr: [G; OUT_38] = { let __args: [G; IN_38] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[38].get_mut(&__args[..]) { 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_36: G = __r_arr[0]; + let __v_37: G = __r_arr[1]; + let __v_38: G = __r_arr[2]; + let __v_39: G = __r_arr[3]; + let __v_40: G = __r_arr[4]; + 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_10] = { let __args: [G; IN_10] = [__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[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_38] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __ret: [G; OUT_38] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + record.function_queries[38].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_39: usize = 18; +const IN_39: usize = 18; +const OUT_39: usize = 8; +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]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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]; + 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 __v_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + let __v_28: G = __loaded[10]; + let __v_29: G = __loaded[11]; + let __v_30: G = __loaded[12]; + let __v_31: G = __loaded[13]; + let __v_32: G = __loaded[14]; + let __v_33: G = __loaded[15]; + let __v_34: G = __loaded[16]; + let __v_35: G = __loaded[17]; + let __r_arr: [G; OUT_39] = { let __args: [G; IN_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __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[39].get_mut(&__args[..]) { 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_36: G = __r_arr[0]; + let __v_37: G = __r_arr[1]; + let __v_38: G = __r_arr[2]; + let __v_39: G = __r_arr[3]; + let __v_40: G = __r_arr[4]; + 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_10] = { let __args: [G; IN_10] = [__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[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_39] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __ret: [G; OUT_39] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + record.function_queries[39].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +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]; + let __v_3: G = inp[3]; + 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]; + 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 __v_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + let __v_28: G = __loaded[10]; + let __v_29: G = __loaded[11]; + let __v_30: G = __loaded[12]; + let __v_31: G = __loaded[13]; + let __v_32: G = __loaded[14]; + 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 !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]; + let __v_39: G = __r_arr[3]; + let __v_40: G = __r_arr[4]; + 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_10] = { let __args: [G; IN_10] = [__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[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_40] = [__v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51]; + record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __ret: [G; OUT_40] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + record.function_queries[40].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_41: usize = 19; +const IN_41: usize = 19; +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]; + let __v_3: G = inp[3]; + 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() { + 7u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_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]; + 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 __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_37, __v_38, __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[32].get_mut(&__args[..]) { 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_55: G = __r_arr[0]; + let __r_arr: [G; OUT_41] = { let __args: [G; IN_41] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[41].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_41] = unsafe { *(result.output.as_ptr() as *const [G; OUT_41]) }; __ret } else { aiur_fn_41(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __ret: [G; OUT_41] = [__v_56]; + record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[32].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; + let __ret: [G; OUT_41] = [__v_19]; + record.function_queries[41].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_42: usize = 19; +const IN_42: usize = 19; +const OUT_42: usize = 1; +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]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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() { + 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 __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_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]; + 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 __r_arr: [G; OUT_42] = { let __args: [G; IN_42] = [__v_37, __v_38, __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[42].get_mut(&__args[..]) { 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_55: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[32].get_mut(&__args[..]) { 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_56: G = __r_arr[0]; + let __ret: [G; OUT_42] = [__v_56]; + record.function_queries[42].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[32].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; + let __ret: [G; OUT_42] = [__v_19]; + record.function_queries[42].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_43], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + 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 __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_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]; + 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 __r_arr: [G; OUT_43] = { let __args: [G; IN_43] = [__v_37, __v_38, __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[43].get_mut(&__args[..]) { 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_55: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[32].get_mut(&__args[..]) { 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_56: G = __r_arr[0]; + let __ret: [G; OUT_43] = [__v_56]; + record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[32].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; + let __ret: [G; OUT_43] = [__v_19]; + record.function_queries[43].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_44: usize = 2; +const IN_44: usize = 2; +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_44], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 3] = [__v_34, __v_33, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(0); + let __v_37: G = { let __values: [G; 3] = [__v_36, __v_32, __v_35]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = G::from_u64(0); + let __v_39: G = { let __values: [G; 3] = [__v_38, __v_31, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = G::from_u64(0); + let __v_41: G = { let __values: [G; 3] = [__v_40, __v_30, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_42: G = G::from_u64(0); + let __v_43: G = { let __values: [G; 3] = [__v_42, __v_29, __v_41]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_44: G = G::from_u64(0); + let __v_45: G = { let __values: [G; 3] = [__v_44, __v_28, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = G::from_u64(0); + let __v_47: G = { let __values: [G; 3] = [__v_46, __v_27, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = G::from_u64(0); + let __v_49: G = { let __values: [G; 3] = [__v_48, __v_26, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = G::from_u64(0); + let __v_51: G = { let __values: [G; 3] = [__v_50, __v_25, __v_49]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_52: G = G::from_u64(0); + let __v_53: G = { let __values: [G; 3] = [__v_52, __v_24, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = G::from_u64(0); + let __v_55: G = { let __values: [G; 3] = [__v_54, __v_23, __v_53]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_56: G = G::from_u64(0); + let __v_57: G = { let __values: [G; 3] = [__v_56, __v_22, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = G::from_u64(0); + let __v_59: G = { let __values: [G; 3] = [__v_58, __v_21, __v_57]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_60: G = G::from_u64(0); + let __v_61: G = { let __values: [G; 3] = [__v_60, __v_20, __v_59]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_62: G = G::from_u64(0); + let __v_63: G = { let __values: [G; 3] = [__v_62, __v_19, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = G::from_u64(0); + let __v_65: G = { let __values: [G; 3] = [__v_64, __v_18, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_66: G = G::from_u64(0); + let __v_67: G = { let __values: [G; 3] = [__v_66, __v_17, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = G::from_u64(0); + let __v_69: G = { let __values: [G; 3] = [__v_68, __v_16, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 3] = [__v_70, __v_15, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_72: G = G::from_u64(0); + let __v_73: G = { let __values: [G; 3] = [__v_72, __v_14, __v_71]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = G::from_u64(0); + let __v_75: G = { let __values: [G; 3] = [__v_74, __v_13, __v_73]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 3] = [__v_76, __v_12, __v_75]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_78: G = G::from_u64(0); + let __v_79: G = { let __values: [G; 3] = [__v_78, __v_11, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_80: G = G::from_u64(0); + let __v_81: G = { let __values: [G; 3] = [__v_80, __v_10, __v_79]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_82: G = G::from_u64(0); + let __v_83: G = { let __values: [G; 3] = [__v_82, __v_9, __v_81]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_84: G = G::from_u64(0); + let __v_85: G = { let __values: [G; 3] = [__v_84, __v_8, __v_83]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_86: G = G::from_u64(0); + let __v_87: G = { let __values: [G; 3] = [__v_86, __v_7, __v_85]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_88: G = G::from_u64(0); + let __v_89: G = { let __values: [G; 3] = [__v_88, __v_6, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_90: G = G::from_u64(0); + let __v_91: G = { let __values: [G; 3] = [__v_90, __v_5, __v_89]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_92: G = G::from_u64(0); + let __v_93: G = { let __values: [G; 3] = [__v_92, __v_4, __v_91]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_94: G = G::from_u64(0); + let __v_95: G = { let __values: [G; 3] = [__v_94, __v_3, __v_93]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_96: G = G::from_u64(0); + let __v_97: G = { let __values: [G; 3] = [__v_96, __v_2, __v_95]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_44] = [__v_97]; + record.function_queries[44].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_45: usize = 2; +const IN_45: usize = 2; +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_45], 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 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(0); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_2: G = G::from_u64(1); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_2: G = G::from_u64(2); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].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_2: G = G::from_u64(4); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_2: G = G::from_u64(5); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_2: G = G::from_u64(6); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].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_2: G = G::from_u64(8); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_2: G = G::from_u64(9); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_2: G = G::from_u64(10); + let __ret: [G; OUT_45] = [__v_2]; + record.function_queries[45].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_46: usize = 9; +const IN_46: usize = 9; +const OUT_46: usize = 8; +fn aiur_fn_46( + inp: [G; IN_46], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_46], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __r_arr: [G; OUT_46] = { let __args: [G; IN_46] = [__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[46].get_mut(&__args[..]) { 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 __v_19: G = __r_arr[1]; + let __v_20: G = __r_arr[2]; + let __v_21: G = __r_arr[3]; + let __v_22: G = __r_arr[4]; + let __v_23: G = __r_arr[5]; + let __v_24: G = __r_arr[6]; + let __v_25: G = __r_arr[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_30: G = __r_arr[4]; + 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_46] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + 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 __ret: [G; OUT_46] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; + record.function_queries[46].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_47: usize = 9; +const IN_47: usize = 9; +const OUT_47: usize = 9; +fn aiur_fn_47( + inp: [G; IN_47], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_47], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __r_arr: [G; OUT_47] = { let __args: [G; IN_47] = [__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[47].get_mut(&__args[..]) { 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_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __v_20: G = __r_arr[2]; + let __v_21: G = __r_arr[3]; + let __v_22: G = __r_arr[4]; + let __v_23: G = __r_arr[5]; + let __v_24: G = __r_arr[6]; + let __v_25: G = __r_arr[7]; + let __v_26: G = __r_arr[8]; + let __ret: [G; OUT_47] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_47] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + record.function_queries[47].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_48: usize = 10; +const IN_48: usize = 10; +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_48], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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_0.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_48] = [__v_12]; + record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + 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]; let __cu = unconstrained; if let Some(result) = record.function_queries[46].get_mut(&__args[..]) { 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 __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + 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_47] = { let __args: [G; IN_47] = [__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[47].get_mut(&__args[..]) { 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_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __v_20: G = __r_arr[2]; + let __v_21: G = __r_arr[3]; + let __v_22: G = __r_arr[4]; + let __v_23: G = __r_arr[5]; + let __v_24: G = __r_arr[6]; + let __v_25: G = __r_arr[7]; + let __v_26: G = __r_arr[8]; + let __v_27: G = G::from_u64(0); + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__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[48].get_mut(&__args[..]) { 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_28: G = __r_arr[0]; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { 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 __ret: [G; OUT_48] = [__v_29]; + record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; + 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 __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; + 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 = G::from_u64(1); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__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[48].get_mut(&__args[..]) { 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_37: G = __r_arr[0]; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__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[48].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { 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 __ret: [G; OUT_48] = [__v_39]; + record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; + 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 __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; + 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 = G::from_u64(2); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__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[48].get_mut(&__args[..]) { 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_37: G = __r_arr[0]; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__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[48].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_48] = unsafe { *(result.output.as_ptr() as *const [G; OUT_48]) }; __ret } else { aiur_fn_48(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { 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 __ret: [G; OUT_48] = [__v_39]; + record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_10: G = G::from_u64(3); + let __r_arr: [G; OUT_35] = { let __args: [G; IN_35] = [__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[35].get_mut(&__args[..]) { 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 __ret: [G; OUT_48] = [__v_11]; + record.function_queries[48].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +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_49], 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_49] = [__v_1]; + record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + let __v_9: G = __loaded[4]; + let __v_10: G = __loaded[5]; + let __v_11: G = __loaded[6]; + let __v_12: G = __loaded[7]; + let __v_13: G = __loaded[8]; + let __v_14: G = __loaded[9]; + let __v_15: G = __loaded[10]; + let __v_16: G = __loaded[11]; + let __v_17: G = __loaded[12]; + let __v_18: G = __loaded[13]; + let __v_19: G = __loaded[14]; + let __v_20: G = __loaded[15]; + let __v_21: G = __loaded[16]; + let __v_22: G = __loaded[17]; + let __r_arr: [G; OUT_49] = { let __args: [G; IN_49] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[49].get_mut(&__args[..]) { 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_23: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { 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_24: G = __r_arr[0]; + let __ret: [G; OUT_49] = [__v_24]; + record.function_queries[49].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_50: usize = 2; +const IN_50: usize = 2; +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_50], 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_50] = [__v_1]; + record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 9] = { let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + let __v_9: G = __loaded[4]; + let __v_10: G = __loaded[5]; + let __v_11: G = __loaded[6]; + let __v_12: G = __loaded[7]; + let __v_13: G = __loaded[8]; + let __r_arr: [G; OUT_50] = { let __args: [G; IN_50] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_48] = { let __args: [G; IN_48] = [__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[48].get_mut(&__args[..]) { 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_15: G = __r_arr[0]; + let __ret: [G; OUT_50] = [__v_15]; + record.function_queries[50].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +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_51], 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_51] = [__v_1]; + record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + 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 !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_5: G = __r_arr[0]; + 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 !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 __ret: [G; OUT_51] = [__v_6]; + record.function_queries[51].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +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_52], 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_52] = [__v_4]; + record.function_queries[52].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_52] = [__v_4]; + record.function_queries[52].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_52] = [__v_4]; + record.function_queries[52].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_52] = [__v_4]; + record.function_queries[52].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_53: usize = 13; +const IN_53: usize = 13; +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_53], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + let __v_24: G = __loaded[11]; + let __v_25: G = __loaded[12]; + let __v_26: G = __loaded[13]; + let __v_27: G = __loaded[14]; + let __v_28: G = __loaded[15]; + let __v_29: G = __loaded[16]; + let __v_30: G = __loaded[17]; + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_31: G = __loaded[0]; + let __v_32: G = __loaded[1]; + let __v_33: G = __loaded[2]; + let __v_34: G = __loaded[3]; + let __v_35: G = __loaded[4]; + let __v_36: G = __loaded[5]; + let __v_37: G = __loaded[6]; + let __v_38: G = __loaded[7]; + let __v_39: G = __loaded[8]; + let __v_40: G = __loaded[9]; + let __v_41: G = __loaded[10]; + let __v_42: G = __loaded[11]; + let __v_43: G = __loaded[12]; + let __v_44: G = __loaded[13]; + let __v_45: G = __loaded[14]; + let __v_46: G = __loaded[15]; + let __v_47: G = __loaded[16]; + let __v_48: G = __loaded[17]; + let __r_arr: [G; OUT_45] = { let __args: [G; IN_45] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[45].get_mut(&__args[..]) { 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 = G::from_u64(0); + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_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[32].get_mut(&__args[..]) { 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_51: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_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_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { 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_52: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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_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_53] = [__v_54]; + record.function_queries[53].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_54: usize = 10; +const IN_54: usize = 10; +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]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_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]; + let __v_20: G = __loaded[10]; + let __v_21: G = __loaded[11]; + let __v_22: G = __loaded[12]; + let __v_23: G = __loaded[13]; + let __v_24: G = __loaded[14]; + let __v_25: G = __loaded[15]; + let __v_26: G = __loaded[16]; + let __v_27: G = __loaded[17]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_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[32].get_mut(&__args[..]) { 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_28: G = __r_arr[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_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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 __ret: [G; OUT_54] = [__v_29]; + record.function_queries[54].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_55: usize = 2; +const IN_55: usize = 2; +const OUT_55: usize = 1; +fn aiur_fn_55( + inp: [G; IN_55], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_55], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + 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 }; + 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]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_55] = [__v_1]; + record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { 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_13: G = __r_arr[0]; + let __r_arr: [G; OUT_54] = { let __args: [G; IN_54] = [__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[54].get_mut(&__args[..]) { 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 __ret: [G; OUT_55] = [__v_14]; + record.function_queries[55].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_56: usize = 45; +const IN_56: usize = 45; +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_56], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_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]; + let __v_52: G = __loaded[7]; + let __v_53: G = __loaded[8]; + let __v_54: G = __loaded[9]; + let __v_55: G = __loaded[10]; + let __v_56: G = __loaded[11]; + let __v_57: G = __loaded[12]; + let __v_58: G = __loaded[13]; + let __v_59: G = __loaded[14]; + let __v_60: G = __loaded[15]; + let __v_61: G = __loaded[16]; + let __v_62: G = __loaded[17]; + 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_726] = { let __args: [G; IN_726] = [__v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __v_67: G = __r_arr[1]; + let __v_68: G = __r_arr[2]; + let __v_69: G = __r_arr[3]; + let __v_70: G = __r_arr[4]; + let __v_71: G = __r_arr[5]; + let __v_72: G = __r_arr[6]; + let __v_73: G = __r_arr[7]; + let __v_74: G = G::from_u64(0); + let __r_arr: [G; OUT_55] = { let __args: [G; IN_55] = [__v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[55].get_mut(&__args[..]) { 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_75: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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_32] = { let __args: [G; IN_32] = [__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[32].get_mut(&__args[..]) { 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_77: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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_78: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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_79: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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_80: G = __r_arr[0]; + 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_80]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_81: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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_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_56] = [__v_83]; + record.function_queries[56].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_57: usize = 11; +const IN_57: usize = 11; +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_57], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + let __v_15: G = __loaded[4]; + let __v_16: G = __loaded[5]; + let __v_17: G = __loaded[6]; + let __v_18: G = __loaded[7]; + let __v_19: G = __loaded[8]; + let __v_20: G = __loaded[9]; + let __v_21: G = __loaded[10]; + let __v_22: G = __loaded[11]; + let __v_23: G = __loaded[12]; + let __v_24: G = __loaded[13]; + let __v_25: G = __loaded[14]; + let __v_26: G = __loaded[15]; + 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_32] = { let __args: [G; IN_32] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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[32].get_mut(&__args[..]) { 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_30: G = __r_arr[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_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_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_57] = [__v_32]; + record.function_queries[57].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_58: usize = 11; +const IN_58: usize = 11; +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_58], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + let __v_15: G = __loaded[4]; + let __v_16: G = __loaded[5]; + let __v_17: G = __loaded[6]; + let __v_18: G = __loaded[7]; + let __v_19: G = __loaded[8]; + let __v_20: G = __loaded[9]; + let __v_21: G = __loaded[10]; + let __v_22: G = __loaded[11]; + let __v_23: G = __loaded[12]; + let __v_24: G = __loaded[13]; + let __v_25: G = __loaded[14]; + let __v_26: G = __loaded[15]; + let __v_27: G = __loaded[16]; + let __v_28: G = __loaded[17]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_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[32].get_mut(&__args[..]) { 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_29: G = __r_arr[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_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_52] = { let __args: [G; IN_52] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[52].get_mut(&__args[..]) { 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_31: G = __r_arr[0]; + let __ret: [G; OUT_58] = [__v_31]; + record.function_queries[58].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_59: usize = 35; +const IN_59: usize = 35; +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_59], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_33.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_35: G = __loaded[0]; + let __v_36: G = __loaded[1]; + let __v_37: G = __loaded[2]; + let __v_38: G = __loaded[3]; + let __v_39: G = __loaded[4]; + let __v_40: G = __loaded[5]; + let __v_41: G = __loaded[6]; + let __v_42: G = __loaded[7]; + let __v_43: G = __loaded[8]; + let __v_44: G = __loaded[9]; + let __v_45: G = __loaded[10]; + let __v_46: G = __loaded[11]; + let __v_47: G = __loaded[12]; + let __v_48: G = __loaded[13]; + let __v_49: G = __loaded[14]; + let __v_50: G = __loaded[15]; + 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_32] = { let __args: [G; IN_32] = [__v_35, __v_36, __v_37, __v_38, __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[32].get_mut(&__args[..]) { 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_54: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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_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_59] = [__v_59]; + record.function_queries[59].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_60: usize = 2; +const IN_60: usize = 2; +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_60], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_60] = [__v_1]; + record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_37, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_59] = { let __args: [G; IN_59] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_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[59].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_59] = unsafe { *(result.output.as_ptr() as *const [G; OUT_59]) }; __ret } else { aiur_fn_59(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __ret: [G; OUT_60] = [__v_39]; + record.function_queries[60].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_61: usize = 38; +const IN_61: usize = 38; +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_61], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_35.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_38: G = __loaded[0]; + let __v_39: G = __loaded[1]; + let __v_40: G = __loaded[2]; + let __v_41: G = __loaded[3]; + let __v_42: G = __loaded[4]; + let __v_43: G = __loaded[5]; + let __v_44: G = __loaded[6]; + let __v_45: G = __loaded[7]; + let __v_46: G = __loaded[8]; + let __v_47: G = __loaded[9]; + let __v_48: G = __loaded[10]; + let __v_49: G = __loaded[11]; + let __v_50: G = __loaded[12]; + let __v_51: G = __loaded[13]; + let __v_52: G = __loaded[14]; + let __v_53: G = __loaded[15]; + let __v_54: G = __loaded[16]; + let __v_55: G = __loaded[17]; + let __v_56: G = G::from_u64(2); + let __v_57: G = (__v_56 * __v_1); + let __v_58: G = G::from_u64(4); + let __v_59: G = (__v_58 * __v_2); + let __v_60: G = (__v_57 + __v_59); + let __v_61: G = (__v_0 + __v_60); + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __v_64: G = __r_arr[2]; + let __v_65: G = __r_arr[3]; + let __v_66: G = __r_arr[4]; + let __v_67: G = __r_arr[5]; + let __v_68: G = __r_arr[6]; + let __v_69: G = __r_arr[7]; + let __v_70: G = G::from_u64(0); + let __r_arr: [G; OUT_60] = { let __args: [G; IN_60] = [__v_36, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[60].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_60] = unsafe { *(result.output.as_ptr() as *const [G; OUT_60]) }; __ret } else { aiur_fn_60(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_72: G = __r_arr[0]; + let __r_arr: [G; OUT_32] = { let __args: [G; IN_32] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { 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_73: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_34] = { let __args: [G; IN_34] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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 __v_78: G = { let __values: [G; 3] = [__v_70, __v_61, __v_77]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_61] = [__v_78]; + record.function_queries[61].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_62: usize = 10; +const IN_62: usize = 10; +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_62], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { 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_10: G = __r_arr[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_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_11: G = __r_arr[0]; + let __ret: [G; OUT_62] = [__v_11]; + record.function_queries[62].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_63: usize = 18; +const IN_63: usize = 18; +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_63], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { 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_18: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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 __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_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[34].get_mut(&__args[..]) { 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_20: G = __r_arr[0]; + let __ret: [G; OUT_63] = [__v_20]; + record.function_queries[63].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_64: usize = 46; +const IN_64: usize = 46; +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_64], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __v_49: G = { let __values: [G; 3] = [__v_46, __v_47, __v_48]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_64] = [__v_49]; + record.function_queries[64].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_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_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[61].get_mut(&__args[..]) { 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_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_64] = [__v_49]; + record.function_queries[64].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_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_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[56].get_mut(&__args[..]) { 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_64] = [__v_49]; + record.function_queries[64].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_65: usize = 2; +const IN_65: usize = 2; +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_65], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + let __v_38: G = __loaded[36]; + let __v_39: G = __loaded[37]; + let __v_40: G = __loaded[38]; + let __v_41: G = __loaded[39]; + let __v_42: G = __loaded[40]; + let __v_43: G = __loaded[41]; + let __v_44: G = __loaded[42]; + let __v_45: G = __loaded[43]; + let __v_46: G = __loaded[44]; + let __v_47: G = __loaded[45]; + let __v_48: G = __loaded[46]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_65] = [__v_1]; + record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_48, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __r_arr: [G; OUT_64] = { let __args: [G; IN_64] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_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[64].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_64] = unsafe { *(result.output.as_ptr() as *const [G; OUT_64]) }; __ret } else { aiur_fn_64(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __ret: [G; OUT_65] = [__v_50]; + record.function_queries[65].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_66: usize = 46; +const IN_66: usize = 46; +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_66], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_53] = { let __args: [G; IN_53] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[53].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_53] = unsafe { *(result.output.as_ptr() as *const [G; OUT_53]) }; __ret } else { aiur_fn_53(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + 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_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __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[56].get_mut(&__args[..]) { 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_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_57] = { let __args: [G; IN_57] = [__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[57].get_mut(&__args[..]) { 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_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + 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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[58].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_58] = unsafe { *(result.output.as_ptr() as *const [G; OUT_58]) }; __ret } else { aiur_fn_58(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + 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_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[63].get_mut(&__args[..]) { 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_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__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[62].get_mut(&__args[..]) { 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_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__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[62].get_mut(&__args[..]) { 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_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_62] = { let __args: [G; IN_62] = [__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[62].get_mut(&__args[..]) { 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_46: G = __r_arr[0]; + let __ret: [G; OUT_66] = [__v_46]; + record.function_queries[66].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_67: usize = 2; +const IN_67: usize = 2; +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_67], 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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + 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_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 !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_10: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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_11: G = __r_arr[0]; + let __ret: [G; OUT_67] = [__v_11]; + record.function_queries[67].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +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_68], 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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + 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 !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_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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_11: G = __r_arr[0]; + let __ret: [G; OUT_68] = [__v_11]; + record.function_queries[68].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +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_713] = { let __args: [G; IN_713] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + 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_50] = { let __args: [G; IN_50] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[50].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_50] = unsafe { *(result.output.as_ptr() as *const [G; OUT_50]) }; __ret } else { aiur_fn_50(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_34] = { let __args: [G; IN_34] = [__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[34].get_mut(&__args[..]) { 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_11: G = __r_arr[0]; + let __ret: [G; OUT_69] = [__v_11]; + record.function_queries[69].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_70: usize = 49; +const IN_70: usize = 49; +const OUT_70: usize = 1; +fn aiur_fn_70( + inp: [G; IN_70], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_70], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_69] = { let __args: [G; IN_69] = [__v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[69].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_69] = unsafe { *(result.output.as_ptr() as *const [G; OUT_69]) }; __ret } else { aiur_fn_69(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __r_arr: [G; OUT_68] = { let __args: [G; IN_68] = [__v_46, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[68].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_68] = unsafe { *(result.output.as_ptr() as *const [G; OUT_68]) }; __ret } else { aiur_fn_68(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __r_arr: [G; OUT_67] = { let __args: [G; IN_67] = [__v_45, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[67].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_67] = unsafe { *(result.output.as_ptr() as *const [G; OUT_67]) }; __ret } else { aiur_fn_67(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + match __v_0.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __v_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 = G::from_u64(12); + let __r_arr: [G; OUT_65] = { let __args: [G; IN_65] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[65].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_65] = unsafe { *(result.output.as_ptr() as *const [G; OUT_65]) }; __ret } else { aiur_fn_65(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[66].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(1); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[66].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(2); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[66].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(3); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[66].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(4); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[66].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(5); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[66].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(6); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[66].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_52: G = G::from_u64(13); + let __v_53: G = G::from_u64(7); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_66] = { let __args: [G; IN_66] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_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[66].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __r_arr: [G; OUT_36] = { let __args: [G; IN_36] = [__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[36].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __ret: [G; OUT_70] = [__v_62]; + record.function_queries[70].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_71: usize = 1; +const IN_71: usize = 1; +const OUT_71: usize = 2; +fn aiur_fn_71( + inp: [G; IN_71], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_71], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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 __ret: [G; OUT_71] = [__v_2, __v_3]; + record.function_queries[71].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 __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_71] = [__v_4, __v_7]; + record.function_queries[71].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_72: usize = 2; +const IN_72: usize = 2; +const OUT_72: usize = 9; +fn aiur_fn_72( + inp: [G; IN_72], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_72], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_72] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_0]; + record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_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_72] = { let __args: [G; IN_72] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __v_9: G = __r_arr[3]; + let __v_10: G = __r_arr[4]; + let __v_11: G = __r_arr[5]; + let __v_12: G = __r_arr[6]; + let __v_13: G = __r_arr[7]; + let __v_14: G = __r_arr[8]; + let __ret: [G; OUT_72] = [__v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_14]; + record.function_queries[72].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_73: usize = 1; +const IN_73: usize = 1; +const OUT_73: usize = 9; +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 __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; + let __v_3: G = __b1_out[0]; + let __v_4: G = __b1_out[1]; + let __v_5: G = __b1_out[2]; + let __v_6: G = __b1_out[3]; + let __v_7: G = __b1_out[4]; + let __v_8: G = __b1_out[5]; + let __v_9: G = __b1_out[6]; + let __v_10: G = __b1_out[7]; + let __v_11: G = G::from_u64(2); + let __v_12: G = (__v_11 * __v_4); + let __v_13: G = G::from_u64(4); + let __v_14: G = (__v_13 * __v_5); + let __v_15: G = G::from_u64(8); + let __v_16: G = (__v_15 * __v_6); + let __v_17: G = G::from_u64(16); + let __v_18: G = (__v_17 * __v_7); + let __v_19: G = G::from_u64(32); + let __v_20: G = (__v_19 * __v_8); + let __v_21: G = G::from_u64(64); + let __v_22: G = (__v_21 * __v_9); + let __v_23: G = (__v_20 + __v_22); + let __v_24: G = (__v_18 + __v_23); + let __v_25: G = (__v_16 + __v_24); + let __v_26: G = (__v_14 + __v_25); + let __v_27: G = (__v_12 + __v_26); + let __v_28: G = (__v_3 + __v_27); + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __ret: [G; OUT_73] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_2]; + record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_29: G = G::from_u64(1); + let __v_30: G = (__v_28 + __v_29); + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __v_34: G = __r_arr[3]; + let __v_35: G = __r_arr[4]; + let __v_36: G = __r_arr[5]; + let __v_37: G = __r_arr[6]; + let __v_38: G = __r_arr[7]; + let __v_39: G = __r_arr[8]; + let __ret: [G; OUT_73] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; + record.function_queries[73].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_74: usize = 1; +const IN_74: usize = 1; +const OUT_74: usize = 10; +fn aiur_fn_74( + inp: [G; IN_74], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_74], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; + let __v_3: G = __b1_out[0]; + let __v_4: G = __b1_out[1]; + let __v_5: G = __b1_out[2]; + let __v_6: G = __b1_out[3]; + let __v_7: G = __b1_out[4]; + let __v_8: G = __b1_out[5]; + let __v_9: G = __b1_out[6]; + let __v_10: G = __b1_out[7]; + let __v_11: G = G::from_u64(2); + let __v_12: G = (__v_11 * __v_10); + let __v_13: G = (__v_9 + __v_12); + let __v_14: G = G::from_u64(2); + let __v_15: G = (__v_14 * __v_4); + let __v_16: G = G::from_u64(4); + let __v_17: G = (__v_16 * __v_5); + let __v_18: G = G::from_u64(8); + let __v_19: G = (__v_18 * __v_6); + let __v_20: G = G::from_u64(16); + let __v_21: G = (__v_20 * __v_7); + let __v_22: G = (__v_19 + __v_21); + let __v_23: G = (__v_17 + __v_22); + let __v_24: G = (__v_15 + __v_23); + let __v_25: G = (__v_3 + __v_24); + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __ret: [G; OUT_74] = [__v_13, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; + record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(1); + let __v_27: G = (__v_25 + __v_26); + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __ret: [G; OUT_74] = [__v_13, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; + record.function_queries[74].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_75: usize = 1; +const IN_75: usize = 1; +const OUT_75: usize = 10; +fn aiur_fn_75( + inp: [G; IN_75], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_75], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; + let __v_3: G = __b1_out[0]; + let __v_4: G = __b1_out[1]; + let __v_5: G = __b1_out[2]; + let __v_6: G = __b1_out[3]; + let __v_7: G = __b1_out[4]; + let __v_8: G = __b1_out[5]; + let __v_9: G = __b1_out[6]; + let __v_10: G = __b1_out[7]; + let __v_11: G = G::from_u64(2); + let __v_12: G = (__v_11 * __v_8); + let __v_13: G = G::from_u64(4); + let __v_14: G = (__v_13 * __v_9); + let __v_15: G = G::from_u64(8); + let __v_16: G = (__v_15 * __v_10); + let __v_17: G = (__v_14 + __v_16); + let __v_18: G = (__v_12 + __v_17); + let __v_19: G = (__v_7 + __v_18); + let __v_20: G = G::from_u64(2); + let __v_21: G = (__v_20 * __v_4); + let __v_22: G = G::from_u64(4); + let __v_23: G = (__v_22 * __v_5); + let __v_24: G = (__v_21 + __v_23); + let __v_25: G = (__v_3 + __v_24); + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __ret: [G; OUT_75] = [__v_19, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_2]; + record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(1); + let __v_27: G = (__v_25 + __v_26); + let __r_arr: [G; OUT_72] = { let __args: [G; IN_72] = [__v_2, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[72].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_72] = unsafe { *(result.output.as_ptr() as *const [G; OUT_72]) }; __ret } else { aiur_fn_72(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __ret: [G; OUT_75] = [__v_19, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; + record.function_queries[75].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_76: usize = 9; +const IN_76: usize = 9; +const OUT_76: usize = 2; +fn aiur_fn_76( + inp: [G; IN_76], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_76], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __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_76] = [__v_12, __v_0]; + record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + 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 !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_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + 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_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_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 __r_arr: [G; OUT_76] = { let __args: [G; IN_76] = [__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[76].get_mut(&__args[..]) { 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_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_76] = [__v_30, __v_28]; + record.function_queries[76].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_77: usize = 10; +const IN_77: usize = 10; +const OUT_77: usize = 19; +fn aiur_fn_77( + inp: [G; IN_77], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_77], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __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 }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + let __v_15: G = __loaded[4]; + let __v_16: G = __loaded[5]; + let __v_17: G = __loaded[6]; + let __v_18: G = __loaded[7]; + let __v_19: G = __loaded[8]; + let __v_20: G = __loaded[9]; + let __v_21: G = __loaded[10]; + let __v_22: G = __loaded[11]; + let __v_23: G = __loaded[12]; + let __v_24: G = __loaded[13]; + let __v_25: G = __loaded[14]; + let __v_26: G = __loaded[15]; + let __v_27: G = __loaded[16]; + let __v_28: G = __loaded[17]; + let __ret: [G; OUT_77] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_1]; + record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + 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 __v_20: G = __r_arr[9]; + let __v_21: G = __r_arr[10]; + let __v_22: G = __r_arr[11]; + let __v_23: G = __r_arr[12]; + let __v_24: G = __r_arr[13]; + let __v_25: G = __r_arr[14]; + let __v_26: G = __r_arr[15]; + let __v_27: G = __r_arr[16]; + let __v_28: G = __r_arr[17]; + let __v_29: G = __r_arr[18]; + let __v_30: G = G::from_u64(7); + let __v_31: G = { let __values: [G; 18] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = G::from_u64(0); + let __v_33: G = { let __values: [G; 18] = [__v_30, __v_0, __v_31, __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]; 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_13] = { let __args: [G; IN_13] = [__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[13].get_mut(&__args[..]) { 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_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __v_37: G = __r_arr[3]; + let __v_38: G = __r_arr[4]; + let __v_39: G = __r_arr[5]; + let __v_40: G = __r_arr[6]; + let __v_41: G = __r_arr[7]; + let __r_arr: [G; OUT_77] = { let __args: [G; IN_77] = [__v_33, __v_29, __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[77].get_mut(&__args[..]) { 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_42: G = __r_arr[0]; + let __v_43: G = __r_arr[1]; + let __v_44: G = __r_arr[2]; + let __v_45: G = __r_arr[3]; + let __v_46: G = __r_arr[4]; + let __v_47: G = __r_arr[5]; + let __v_48: G = __r_arr[6]; + let __v_49: G = __r_arr[7]; + let __v_50: G = __r_arr[8]; + let __v_51: G = __r_arr[9]; + let __v_52: G = __r_arr[10]; + let __v_53: G = __r_arr[11]; + let __v_54: G = __r_arr[12]; + let __v_55: G = __r_arr[13]; + let __v_56: G = __r_arr[14]; + let __v_57: G = __r_arr[15]; + let __v_58: G = __r_arr[16]; + let __v_59: G = __r_arr[17]; + let __v_60: G = __r_arr[18]; + let __ret: [G; OUT_77] = [__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]; + record.function_queries[77].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_78: usize = 9; +const IN_78: usize = 9; +const OUT_78: usize = 19; +fn aiur_fn_78( + inp: [G; IN_78], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_78], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __ret: [G; OUT_78] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; + record.function_queries[78].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 !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_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_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 __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[78].get_mut(&__args[..]) { 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_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __v_40: G = __r_arr[3]; + let __v_41: G = __r_arr[4]; + let __v_42: G = __r_arr[5]; + let __v_43: G = __r_arr[6]; + let __v_44: G = __r_arr[7]; + let __v_45: G = __r_arr[8]; + let __v_46: G = __r_arr[9]; + let __v_47: G = __r_arr[10]; + let __v_48: G = __r_arr[11]; + let __v_49: G = __r_arr[12]; + let __v_50: G = __r_arr[13]; + let __v_51: G = __r_arr[14]; + let __v_52: G = __r_arr[15]; + let __v_53: G = __r_arr[16]; + let __v_54: G = __r_arr[17]; + let __v_55: G = __r_arr[18]; + let __v_56: G = G::from_u64(8); + let __v_57: G = { let __values: [G; 18] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 18] = [__v_37, __v_38, __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]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = G::from_u64(0); + let __ret: [G; OUT_78] = [__v_56, __v_57, __v_58, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_55]; + record.function_queries[78].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_79: usize = 9; +const IN_79: usize = 9; +const OUT_79: usize = 19; +fn aiur_fn_79( + inp: [G; IN_79], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_79], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __ret: [G; OUT_79] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; + record.function_queries[79].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 !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_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_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 __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __v_40: G = __r_arr[3]; + let __v_41: G = __r_arr[4]; + let __v_42: G = __r_arr[5]; + let __v_43: G = __r_arr[6]; + let __v_44: G = __r_arr[7]; + let __v_45: G = __r_arr[8]; + let __v_46: G = __r_arr[9]; + let __v_47: G = __r_arr[10]; + let __v_48: G = __r_arr[11]; + let __v_49: G = __r_arr[12]; + let __v_50: G = __r_arr[13]; + let __v_51: G = __r_arr[14]; + let __v_52: G = __r_arr[15]; + let __v_53: G = __r_arr[16]; + let __v_54: G = __r_arr[17]; + let __v_55: G = __r_arr[18]; + let __v_56: G = G::from_u64(9); + let __v_57: G = { let __values: [G; 18] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_58: G = { let __values: [G; 18] = [__v_37, __v_38, __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]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_59: G = G::from_u64(0); + let __ret: [G; OUT_79] = [__v_56, __v_57, __v_58, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_55]; + record.function_queries[79].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_80: usize = 1; +const IN_80: usize = 1; +const OUT_80: usize = 19; +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 __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 !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_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 __ret: [G; OUT_80] = [__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, __v_10]; + record.function_queries[80].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 __ret: [G; OUT_80] = [__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, __v_10]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_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_76] = { let __args: [G; IN_76] = [__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[76].get_mut(&__args[..]) { 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 = G::from_u64(2); + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_80] = [__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, __v_21]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_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_76] = { let __args: [G; IN_76] = [__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[76].get_mut(&__args[..]) { 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 = G::from_u64(3); + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_80] = [__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, __v_21]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_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_80] = { let __args: [G; IN_80] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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 = __r_arr[2]; + let __v_23: G = __r_arr[3]; + let __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + let __v_26: G = __r_arr[6]; + let __v_27: G = __r_arr[7]; + let __v_28: G = __r_arr[8]; + let __v_29: G = __r_arr[9]; + let __v_30: G = __r_arr[10]; + let __v_31: G = __r_arr[11]; + let __v_32: G = __r_arr[12]; + let __v_33: G = __r_arr[13]; + let __v_34: G = __r_arr[14]; + let __v_35: G = __r_arr[15]; + let __v_36: G = __r_arr[16]; + let __v_37: G = __r_arr[17]; + let __v_38: G = __r_arr[18]; + let __v_39: G = G::from_u64(4); + let __v_40: G = { let __values: [G; 18] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; 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_39, __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_40, __v_38]; + record.function_queries[80].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 __ret: [G; OUT_80] = [__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, __v_10]; + record.function_queries[80].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 __ret: [G; OUT_80] = [__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, __v_10]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + 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 __v_20: G = __r_arr[9]; + let __v_21: G = __r_arr[10]; + let __v_22: G = __r_arr[11]; + let __v_23: G = __r_arr[12]; + let __v_24: G = __r_arr[13]; + let __v_25: G = __r_arr[14]; + let __v_26: G = __r_arr[15]; + let __v_27: G = __r_arr[16]; + let __v_28: G = __r_arr[17]; + let __v_29: G = __r_arr[18]; + let __v_30: G = { let __values: [G; 18] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28]; 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_77] = { let __args: [G; IN_77] = [__v_30, __v_29, __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[77].get_mut(&__args[..]) { 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_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __v_34: G = __r_arr[3]; + let __v_35: G = __r_arr[4]; + let __v_36: G = __r_arr[5]; + let __v_37: G = __r_arr[6]; + let __v_38: G = __r_arr[7]; + let __v_39: G = __r_arr[8]; + let __v_40: G = __r_arr[9]; + let __v_41: G = __r_arr[10]; + let __v_42: G = __r_arr[11]; + let __v_43: G = __r_arr[12]; + let __v_44: G = __r_arr[13]; + let __v_45: G = __r_arr[14]; + let __v_46: G = __r_arr[15]; + let __v_47: G = __r_arr[16]; + let __v_48: G = __r_arr[17]; + let __v_49: G = __r_arr[18]; + let __ret: [G; OUT_80] = [__v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_78] = { let __args: [G; IN_78] = [__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[78].get_mut(&__args[..]) { 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_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 __v_20: G = __r_arr[9]; + let __v_21: G = __r_arr[10]; + let __v_22: G = __r_arr[11]; + let __v_23: G = __r_arr[12]; + let __v_24: G = __r_arr[13]; + let __v_25: G = __r_arr[14]; + let __v_26: G = __r_arr[15]; + let __v_27: G = __r_arr[16]; + let __v_28: G = __r_arr[17]; + let __v_29: G = __r_arr[18]; + let __ret: [G; OUT_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 9u64 => { + let __r_arr: [G; OUT_79] = { let __args: [G; IN_79] = [__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[79].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_79] = unsafe { *(result.output.as_ptr() as *const [G; OUT_79]) }; __ret } else { aiur_fn_79(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_20: G = __r_arr[9]; + let __v_21: G = __r_arr[10]; + let __v_22: G = __r_arr[11]; + let __v_23: G = __r_arr[12]; + let __v_24: G = __r_arr[13]; + let __v_25: G = __r_arr[14]; + let __v_26: G = __r_arr[15]; + let __v_27: G = __r_arr[16]; + let __v_28: G = __r_arr[17]; + let __v_29: G = __r_arr[18]; + let __ret: [G; OUT_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 10u64 => { + 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 !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_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 __v_20: G = __r_arr[9]; + let __v_21: G = __r_arr[10]; + let __v_22: G = __r_arr[11]; + let __v_23: G = __r_arr[12]; + let __v_24: G = __r_arr[13]; + let __v_25: G = __r_arr[14]; + let __v_26: G = __r_arr[15]; + let __v_27: G = __r_arr[16]; + let __v_28: G = __r_arr[17]; + let __v_29: G = __r_arr[18]; + let __ret: [G; OUT_80] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; + record.function_queries[80].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 __ret: [G; OUT_80] = [__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, __v_10]; + record.function_queries[80].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_81: usize = 9; +const IN_81: usize = 9; +const OUT_81: usize = 19; +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 __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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_80] = { let __args: [G; IN_80] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __v_11: G = __r_arr[2]; + let __v_12: G = __r_arr[3]; + let __v_13: G = __r_arr[4]; + let __v_14: G = __r_arr[5]; + let __v_15: G = __r_arr[6]; + let __v_16: G = __r_arr[7]; + let __v_17: G = __r_arr[8]; + let __v_18: G = __r_arr[9]; + let __v_19: G = __r_arr[10]; + let __v_20: G = __r_arr[11]; + let __v_21: G = __r_arr[12]; + let __v_22: G = __r_arr[13]; + let __v_23: G = __r_arr[14]; + let __v_24: G = __r_arr[15]; + let __v_25: G = __r_arr[16]; + let __v_26: G = __r_arr[17]; + let __v_27: G = __r_arr[18]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __v_37: G = __r_arr[9]; + let __v_38: G = __r_arr[10]; + let __v_39: G = __r_arr[11]; + let __v_40: G = __r_arr[12]; + let __v_41: G = __r_arr[13]; + let __v_42: G = __r_arr[14]; + let __v_43: G = __r_arr[15]; + let __v_44: G = __r_arr[16]; + let __v_45: G = __r_arr[17]; + let __v_46: G = __r_arr[18]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __v_49: G = __r_arr[2]; + let __v_50: G = __r_arr[3]; + let __v_51: G = __r_arr[4]; + let __v_52: G = __r_arr[5]; + let __v_53: G = __r_arr[6]; + let __v_54: G = __r_arr[7]; + let __v_55: G = __r_arr[8]; + let __v_56: G = __r_arr[9]; + let __v_57: G = __r_arr[10]; + let __v_58: G = __r_arr[11]; + let __v_59: G = __r_arr[12]; + let __v_60: G = __r_arr[13]; + let __v_61: G = __r_arr[14]; + let __v_62: G = __r_arr[15]; + let __v_63: G = __r_arr[16]; + let __v_64: G = __r_arr[17]; + let __v_65: G = __r_arr[18]; + let __v_66: G = G::from_u64(10); + let __v_67: G = { let __values: [G; 18] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __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 __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = { let __values: [G; 18] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = { let __values: [G; 18] = [__v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_70: G = G::from_u64(0); + let __ret: [G; OUT_81] = [__v_66, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_67, __v_68, __v_69, __v_70, __v_70, __v_70, __v_70, __v_70, __v_70, __v_65]; + record.function_queries[81].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_82: usize = 17; +const IN_82: usize = 17; +const OUT_82: usize = 9; +fn aiur_fn_82( + inp: [G; IN_82], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_82], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __r_arr: [G; OUT_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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 => { + let __ret: [G; OUT_82] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__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 !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_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __v_20: G = __r_arr[2]; + let __v_21: G = __r_arr[3]; + let __v_22: G = __r_arr[4]; + let __v_23: G = __r_arr[5]; + let __v_24: G = __r_arr[6]; + let __v_25: G = __r_arr[7]; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__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[82].get_mut(&__args[..]) { 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_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 __v_30: G = __r_arr[4]; + let __v_31: G = __r_arr[5]; + let __v_32: G = __r_arr[6]; + let __v_33: G = __r_arr[7]; + let __v_34: G = __r_arr[8]; + let __v_35: G = G::from_u64(1); + let __v_36: G = { let __values: [G; 9] = [__v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = G::from_u64(0); + let __ret: [G; OUT_82] = [__v_35, __v_36, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37, __v_37]; + record.function_queries[82].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_83: usize = 1; +const IN_83: usize = 1; +const OUT_83: usize = 10; +fn aiur_fn_83( + inp: [G; IN_83], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_83], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_74] = { let __args: [G; IN_74] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[74].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_74] = unsafe { *(result.output.as_ptr() as *const [G; OUT_74]) }; __ret } else { aiur_fn_74(__args, record, io_buffer, __cu)? } }; + 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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_83] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_10]; + record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __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 __v_20: G = __r_arr[8]; + let __v_21: G = __r_arr[9]; + let __r_arr: [G; OUT_82] = { let __args: [G; IN_82] = [__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[82].get_mut(&__args[..]) { 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 = __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 __v_28: G = __r_arr[6]; + let __v_29: G = __r_arr[7]; + let __v_30: G = __r_arr[8]; + let __ret: [G; OUT_83] = [__v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_21]; + record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 1u64 => { + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_20: G = __r_arr[9]; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_27: G = __r_arr[6]; + let __v_28: G = __r_arr[7]; + let __v_29: G = __r_arr[8]; + let __v_30: G = __r_arr[9]; + let __v_31: G = G::from_u64(2); + let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = G::from_u64(0); + let __ret: [G; OUT_83] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; + record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_20: G = __r_arr[9]; + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_27: G = __r_arr[6]; + let __v_28: G = __r_arr[7]; + let __v_29: G = __r_arr[8]; + let __v_30: G = __r_arr[9]; + let __v_31: G = G::from_u64(3); + let __v_32: G = { let __values: [G; 9] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = { let __values: [G; 9] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29]; let __mq = record.memory_queries.get_mut(&9).ok_or(ExecError::InvalidMemorySize(9))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = G::from_u64(0); + let __ret: [G; OUT_83] = [__v_31, __v_32, __v_33, __v_34, __v_34, __v_34, __v_34, __v_34, __v_34, __v_30]; + record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_11: G = G::from_u64(4); + let __ret: [G; OUT_83] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + record.function_queries[83].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_84: usize = 1; +const IN_84: usize = 1; +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 __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_29: G = __r_arr[0]; + let __v_30: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_35: G = __r_arr[0]; + let __v_36: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_43: G = __r_arr[0]; + let __v_44: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_45: G = __r_arr[0]; + let __v_46: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_49: G = __r_arr[0]; + let __v_50: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_51: G = __r_arr[0]; + let __v_52: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_57: G = __r_arr[0]; + let __v_58: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_63: G = __r_arr[0]; + let __v_64: G = __r_arr[1]; + let __v_65: G = { let __values: [G; 32] = [__v_1, __v_3, __v_5, __v_7, __v_9, __v_11, __v_13, __v_15, __v_17, __v_19, __v_21, __v_23, __v_25, __v_27, __v_29, __v_31, __v_33, __v_35, __v_37, __v_39, __v_41, __v_43, __v_45, __v_47, __v_49, __v_51, __v_53, __v_55, __v_57, __v_59, __v_61, __v_63]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_65, __v_64]; + record.function_queries[84].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_85: usize = 9; +const IN_85: usize = 9; +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 __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __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_85] = [__v_12, __v_0]; + record.function_queries[85].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 !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_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_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 __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[85].get_mut(&__args[..]) { 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_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 18] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = { let __values: [G; 3] = [__v_39, __v_40, __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_85] = [__v_41, __v_38]; + record.function_queries[85].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.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 __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __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_86] = [__v_12, __v_0]; + record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_83] = { let __args: [G; IN_83] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[83].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_83] = unsafe { *(result.output.as_ptr() as *const [G; OUT_83]) }; __ret } else { aiur_fn_83(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + 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_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_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 __v_24: G = __r_arr[4]; + 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_86] = { let __args: [G; IN_86] = [__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[86].get_mut(&__args[..]) { 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_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_86] = [__v_32, __v_29]; + record.function_queries[86].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +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_87], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __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]; + 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 !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_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_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_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 !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_87] = [__v_23, __v_21]; + record.function_queries[87].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_88: usize = 1; +const IN_88: usize = 1; +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_88], 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 !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 __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 __r_arr: [G; OUT_85] = { let __args: [G; IN_85] = [__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[85].get_mut(&__args[..]) { 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_88] = [__v_10, __v_11]; + record.function_queries[88].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +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_89], 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 !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 __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 __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 !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_89] = [__v_10, __v_11]; + record.function_queries[89].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +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_90], 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 !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 __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 __r_arr: [G; OUT_86] = { let __args: [G; IN_86] = [__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[86].get_mut(&__args[..]) { 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_90] = [__v_10, __v_11]; + record.function_queries[90].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_91], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + 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_91] = [__v_1, __v_2]; + record.function_queries[91].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_91] = [__v_1, __v_2]; + record.function_queries[91].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_91] = [__v_1, __v_2]; + record.function_queries[91].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_91] = [__v_1, __v_2]; + record.function_queries[91].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_91] = [__v_1, __v_2]; + record.function_queries[91].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_91] = [__v_1, __v_2]; + record.function_queries[91].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_91] = [__v_1, __v_2]; + record.function_queries[91].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_91] = [__v_1, __v_2]; + record.function_queries[91].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_91] = [__v_1, __v_2]; + record.function_queries[91].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_92: usize = 1; +const IN_92: usize = 1; +const OUT_92: usize = 13; +fn aiur_fn_92( + inp: [G; IN_92], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_92], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_91] = { let __args: [G; IN_91] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[91].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __v_7: G = __r_arr[2]; + let __v_8: G = __r_arr[3]; + let __v_9: G = __r_arr[4]; + let __v_10: G = __r_arr[5]; + 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_80] = { let __args: [G; IN_80] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_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 __v_22: G = __r_arr[8]; + let __v_23: G = __r_arr[9]; + let __v_24: G = __r_arr[10]; + let __v_25: G = __r_arr[11]; + let __v_26: G = __r_arr[12]; + let __v_27: G = __r_arr[13]; + let __v_28: G = __r_arr[14]; + let __v_29: G = __r_arr[15]; + let __v_30: G = __r_arr[16]; + let __v_31: G = __r_arr[17]; + let __v_32: G = __r_arr[18]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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 __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 __v_42: G = __r_arr[9]; + let __v_43: G = __r_arr[10]; + let __v_44: G = __r_arr[11]; + let __v_45: G = __r_arr[12]; + let __v_46: G = __r_arr[13]; + let __v_47: G = __r_arr[14]; + let __v_48: G = __r_arr[15]; + let __v_49: G = __r_arr[16]; + let __v_50: G = __r_arr[17]; + let __v_51: G = __r_arr[18]; + let __v_52: G = { let __values: [G; 18] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_53: G = { let __values: [G; 18] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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 __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_92] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_52, __v_53, __v_51]; + record.function_queries[92].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 = 10; +fn aiur_fn_93( + inp: [G; IN_93], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_93], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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 __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 __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = { let __values: [G; 18] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __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_93] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_29, __v_28]; + record.function_queries[93].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_94: usize = 9; +const IN_94: usize = 9; +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_94], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __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_94] = [__v_12, __v_0]; + record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_93] = { let __args: [G; IN_93] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[93].get_mut(&__args[..]) { 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_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + 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_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_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 __v_24: G = __r_arr[4]; + 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_94] = { let __args: [G; IN_94] = [__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[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = G::from_u64(0); + let __v_31: G = { let __values: [G; 11] = [__v_30, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_28]; let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_94] = [__v_31, __v_29]; + record.function_queries[94].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_95: usize = 1; +const IN_95: usize = 1; +const OUT_95: usize = 45; +fn aiur_fn_95( + inp: [G; IN_95], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_95], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; + let __v_3: G = __b1_out[0]; + let __v_4: G = __b1_out[1]; + let __v_5: G = __b1_out[2]; + let __v_6: G = __b1_out[3]; + let __v_7: G = __b1_out[4]; + 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_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_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_73] = { let __args: [G; IN_73] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_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 __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + 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_73] = { let __args: [G; IN_73] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_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_73] = { let __args: [G; IN_73] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __v_40: G = __r_arr[2]; + let __v_41: G = __r_arr[3]; + let __v_42: G = __r_arr[4]; + let __v_43: G = __r_arr[5]; + 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_73] = { let __args: [G; IN_73] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __v_49: G = __r_arr[2]; + let __v_50: G = __r_arr[3]; + let __v_51: G = __r_arr[4]; + let __v_52: G = __r_arr[5]; + let __v_53: G = __r_arr[6]; + let __v_54: G = __r_arr[7]; + let __v_55: G = __r_arr[8]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __v_58: G = __r_arr[2]; + let __v_59: G = __r_arr[3]; + let __v_60: G = __r_arr[4]; + let __v_61: G = __r_arr[5]; + let __v_62: G = __r_arr[6]; + let __v_63: G = __r_arr[7]; + let __v_64: G = __r_arr[8]; + let __v_65: G = __r_arr[9]; + let __v_66: G = __r_arr[10]; + let __v_67: G = __r_arr[11]; + let __v_68: G = __r_arr[12]; + let __v_69: G = __r_arr[13]; + let __v_70: G = __r_arr[14]; + let __v_71: G = __r_arr[15]; + let __v_72: G = __r_arr[16]; + let __v_73: G = __r_arr[17]; + let __v_74: G = __r_arr[18]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_75: G = __r_arr[0]; + let __v_76: G = __r_arr[1]; + let __v_77: G = __r_arr[2]; + let __v_78: G = __r_arr[3]; + let __v_79: G = __r_arr[4]; + let __v_80: G = __r_arr[5]; + let __v_81: G = __r_arr[6]; + let __v_82: G = __r_arr[7]; + let __v_83: G = __r_arr[8]; + let __r_arr: [G; OUT_94] = { let __args: [G; IN_94] = [__v_83, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[94].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_94] = unsafe { *(result.output.as_ptr() as *const [G; OUT_94]) }; __ret } else { aiur_fn_94(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __v_85: G = __r_arr[1]; + let __v_86: G = { let __values: [G; 18] = [__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]; 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_95] = [__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_86, __v_84, __v_85]; + record.function_queries[95].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_96: usize = 1; +const IN_96: usize = 1; +const OUT_96: usize = 11; +fn aiur_fn_96( + inp: [G; IN_96], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_96], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_80] = unsafe { *(result.output.as_ptr() as *const [G; OUT_80]) }; __ret } else { aiur_fn_80(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + 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 __v_20: G = __r_arr[8]; + let __v_21: G = __r_arr[9]; + let __v_22: G = __r_arr[10]; + let __v_23: G = __r_arr[11]; + let __v_24: G = __r_arr[12]; + let __v_25: G = __r_arr[13]; + let __v_26: G = __r_arr[14]; + let __v_27: G = __r_arr[15]; + let __v_28: G = __r_arr[16]; + let __v_29: G = __r_arr[17]; + let __v_30: G = __r_arr[18]; + let __v_31: G = { let __values: [G; 18] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __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(&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_96] = [__v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_31, __v_30]; + record.function_queries[96].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 = 1; +fn aiur_fn_97( + inp: [G; IN_97], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_97], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_1: G = G::from_u64(0); + let __ret: [G; OUT_97] = [__v_1]; + record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_1: G = G::from_u64(1); + let __ret: [G; OUT_97] = [__v_1]; + record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_1: G = G::from_u64(2); + let __ret: [G; OUT_97] = [__v_1]; + record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_1: G = G::from_u64(3); + let __ret: [G; OUT_97] = [__v_1]; + record.function_queries[97].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_98: usize = 1; +const IN_98: usize = 1; +const OUT_98: usize = 11; +fn aiur_fn_98( + inp: [G; IN_98], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_98], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + 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 !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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __v_6: G = __r_arr[2]; + let __v_7: G = __r_arr[3]; + let __v_8: G = __r_arr[4]; + let __v_9: G = __r_arr[5]; + let __v_10: G = __r_arr[6]; + let __v_11: G = __r_arr[7]; + let __v_12: G = __r_arr[8]; + let __r_arr: [G; OUT_80] = { let __args: [G; IN_80] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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 __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 __v_22: G = __r_arr[9]; + let __v_23: G = __r_arr[10]; + let __v_24: G = __r_arr[11]; + let __v_25: G = __r_arr[12]; + let __v_26: G = __r_arr[13]; + let __v_27: G = __r_arr[14]; + let __v_28: G = __r_arr[15]; + let __v_29: G = __r_arr[16]; + let __v_30: G = __r_arr[17]; + let __v_31: G = __r_arr[18]; + let __v_32: G = { let __values: [G; 18] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30]; 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_98] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_32, __v_31]; + record.function_queries[98].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 = 35; +fn aiur_fn_99( + inp: [G; IN_99], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_99], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_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 __v_20: G = __r_arr[8]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_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 __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_73] = { let __args: [G; IN_73] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __v_32: G = __r_arr[2]; + let __v_33: G = __r_arr[3]; + let __v_34: G = __r_arr[4]; + let __v_35: G = __r_arr[5]; + 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_80] = { let __args: [G; IN_80] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __v_41: G = __r_arr[2]; + let __v_42: G = __r_arr[3]; + let __v_43: G = __r_arr[4]; + let __v_44: G = __r_arr[5]; + let __v_45: G = __r_arr[6]; + let __v_46: G = __r_arr[7]; + let __v_47: G = __r_arr[8]; + let __v_48: G = __r_arr[9]; + let __v_49: G = __r_arr[10]; + let __v_50: G = __r_arr[11]; + let __v_51: G = __r_arr[12]; + let __v_52: G = __r_arr[13]; + let __v_53: G = __r_arr[14]; + let __v_54: G = __r_arr[15]; + let __v_55: G = __r_arr[16]; + let __v_56: G = __r_arr[17]; + let __v_57: G = __r_arr[18]; + let __v_58: G = { let __values: [G; 18] = [__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]; 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_99] = [__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_58, __v_57]; + record.function_queries[99].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_100: usize = 9; +const IN_100: usize = 9; +const OUT_100: usize = 2; +fn aiur_fn_100( + inp: [G; IN_100], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_100], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __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_100] = [__v_12, __v_0]; + record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_99] = { let __args: [G; IN_99] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[99].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_99] = unsafe { *(result.output.as_ptr() as *const [G; OUT_99]) }; __ret } else { aiur_fn_99(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + 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_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_45: G = __r_arr[0]; + let __v_46: G = __r_arr[1]; + let __v_47: G = __r_arr[2]; + let __v_48: G = __r_arr[3]; + let __v_49: G = __r_arr[4]; + 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_100] = { let __args: [G; IN_100] = [__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[100].get_mut(&__args[..]) { 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_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_100] = [__v_56, __v_54]; + record.function_queries[100].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_101: usize = 1; +const IN_101: usize = 1; +const OUT_101: usize = 38; +fn aiur_fn_101( + inp: [G; IN_101], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_101], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; + let __v_3: G = __b1_out[0]; + let __v_4: G = __b1_out[1]; + let __v_5: G = __b1_out[2]; + let __v_6: G = __b1_out[3]; + let __v_7: G = __b1_out[4]; + 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_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_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_73] = { let __args: [G; IN_73] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_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 __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + 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_73] = { let __args: [G; IN_73] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_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_73] = { let __args: [G; IN_73] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __v_40: G = __r_arr[2]; + let __v_41: G = __r_arr[3]; + let __v_42: G = __r_arr[4]; + let __v_43: G = __r_arr[5]; + 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_80] = { let __args: [G; IN_80] = [__v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[80].get_mut(&__args[..]) { 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_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __v_49: G = __r_arr[2]; + let __v_50: G = __r_arr[3]; + let __v_51: G = __r_arr[4]; + let __v_52: G = __r_arr[5]; + let __v_53: G = __r_arr[6]; + let __v_54: G = __r_arr[7]; + let __v_55: G = __r_arr[8]; + let __v_56: G = __r_arr[9]; + let __v_57: G = __r_arr[10]; + let __v_58: G = __r_arr[11]; + let __v_59: G = __r_arr[12]; + let __v_60: G = __r_arr[13]; + let __v_61: G = __r_arr[14]; + let __v_62: G = __r_arr[15]; + let __v_63: G = __r_arr[16]; + let __v_64: G = __r_arr[17]; + let __v_65: G = __r_arr[18]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_66: G = __r_arr[0]; + let __v_67: G = __r_arr[1]; + let __v_68: G = __r_arr[2]; + let __v_69: G = __r_arr[3]; + let __v_70: G = __r_arr[4]; + let __v_71: G = __r_arr[5]; + let __v_72: G = __r_arr[6]; + let __v_73: G = __r_arr[7]; + let __v_74: G = __r_arr[8]; + let __r_arr: [G; OUT_100] = { let __args: [G; IN_100] = [__v_74, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[100].get_mut(&__args[..]) { 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_75: G = __r_arr[0]; + let __v_76: G = __r_arr[1]; + let __v_77: G = { let __values: [G; 18] = [__v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_101] = [__v_3, __v_4, __v_5, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_77, __v_75, __v_76]; + record.function_queries[101].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 = 10; +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 __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 !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 __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 __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 !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_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_102] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11]; + record.function_queries[102].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_103: usize = 1; +const IN_103: usize = 1; +const OUT_103: usize = 18; +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 __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 !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 __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 __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + 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 !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_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __ret: [G; OUT_103] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19, __v_20]; + record.function_queries[103].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 = 46; +fn aiur_fn_104( + inp: [G; IN_104], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_104], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __v_12: G = __r_arr[9]; + let __v_13: G = __r_arr[10]; + let __v_14: G = __r_arr[11]; + 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_104] = [__v_16, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15]; + record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_101] = { let __args: [G; IN_101] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[101].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_101] = unsafe { *(result.output.as_ptr() as *const [G; OUT_101]) }; __ret } else { aiur_fn_101(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __v_12: G = __r_arr[9]; + let __v_13: G = __r_arr[10]; + let __v_14: G = __r_arr[11]; + let __v_15: G = __r_arr[12]; + let __v_16: G = __r_arr[13]; + let __v_17: G = __r_arr[14]; + let __v_18: G = __r_arr[15]; + let __v_19: G = __r_arr[16]; + let __v_20: G = __r_arr[17]; + let __v_21: G = __r_arr[18]; + let __v_22: G = __r_arr[19]; + let __v_23: G = __r_arr[20]; + let __v_24: G = __r_arr[21]; + let __v_25: G = __r_arr[22]; + let __v_26: G = __r_arr[23]; + let __v_27: G = __r_arr[24]; + let __v_28: G = __r_arr[25]; + let __v_29: G = __r_arr[26]; + let __v_30: G = __r_arr[27]; + let __v_31: G = __r_arr[28]; + let __v_32: G = __r_arr[29]; + let __v_33: G = __r_arr[30]; + let __v_34: G = __r_arr[31]; + let __v_35: G = __r_arr[32]; + let __v_36: G = __r_arr[33]; + let __v_37: G = __r_arr[34]; + let __v_38: G = __r_arr[35]; + let __v_39: G = __r_arr[36]; + let __v_40: G = __r_arr[37]; + let __v_41: G = G::from_u64(1); + let __v_42: G = G::from_u64(0); + let __ret: [G; OUT_104] = [__v_41, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_95] = { let __args: [G; IN_95] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[95].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __v_12: G = __r_arr[9]; + let __v_13: G = __r_arr[10]; + let __v_14: G = __r_arr[11]; + let __v_15: G = __r_arr[12]; + let __v_16: G = __r_arr[13]; + let __v_17: G = __r_arr[14]; + let __v_18: G = __r_arr[15]; + let __v_19: G = __r_arr[16]; + let __v_20: G = __r_arr[17]; + let __v_21: G = __r_arr[18]; + let __v_22: G = __r_arr[19]; + let __v_23: G = __r_arr[20]; + let __v_24: G = __r_arr[21]; + let __v_25: G = __r_arr[22]; + let __v_26: G = __r_arr[23]; + let __v_27: G = __r_arr[24]; + let __v_28: G = __r_arr[25]; + let __v_29: G = __r_arr[26]; + let __v_30: G = __r_arr[27]; + let __v_31: G = __r_arr[28]; + let __v_32: G = __r_arr[29]; + let __v_33: G = __r_arr[30]; + let __v_34: G = __r_arr[31]; + let __v_35: G = __r_arr[32]; + let __v_36: G = __r_arr[33]; + let __v_37: G = __r_arr[34]; + let __v_38: G = __r_arr[35]; + let __v_39: G = __r_arr[36]; + let __v_40: G = __r_arr[37]; + let __v_41: G = __r_arr[38]; + let __v_42: G = __r_arr[39]; + let __v_43: G = __r_arr[40]; + let __v_44: G = __r_arr[41]; + let __v_45: G = __r_arr[42]; + 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_104] = [__v_48, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; + record.function_queries[104].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_105: usize = 9; +const IN_105: usize = 9; +const OUT_105: usize = 2; +fn aiur_fn_105( + inp: [G; IN_105], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_105], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __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_105] = [__v_12, __v_0]; + record.function_queries[105].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 !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_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + let __v_42: G = __r_arr[32]; + let __v_43: G = __r_arr[33]; + let __v_44: G = __r_arr[34]; + let __v_45: G = __r_arr[35]; + let __v_46: G = __r_arr[36]; + let __v_47: G = __r_arr[37]; + let __v_48: G = __r_arr[38]; + let __v_49: G = __r_arr[39]; + let __v_50: G = __r_arr[40]; + let __v_51: G = __r_arr[41]; + let __v_52: G = __r_arr[42]; + 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_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __v_58: G = __r_arr[2]; + let __v_59: G = __r_arr[3]; + let __v_60: G = __r_arr[4]; + 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_105] = { let __args: [G; IN_105] = [__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[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __v_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_105] = [__v_67, __v_65]; + record.function_queries[105].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_106: usize = 2; +const IN_106: usize = 2; +const OUT_106: usize = 46; +fn aiur_fn_106( + inp: [G; IN_106], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_106], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_92] = { let __args: [G; IN_92] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[92].get_mut(&__args[..]) { 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_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = __r_arr[9]; + let __v_12: G = __r_arr[10]; + let __v_13: G = __r_arr[11]; + 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_106] = [__v_15, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_14]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + 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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_95] = unsafe { *(result.output.as_ptr() as *const [G; OUT_95]) }; __ret } else { aiur_fn_95(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = __r_arr[9]; + let __v_12: G = __r_arr[10]; + let __v_13: G = __r_arr[11]; + let __v_14: G = __r_arr[12]; + let __v_15: G = __r_arr[13]; + let __v_16: G = __r_arr[14]; + let __v_17: G = __r_arr[15]; + let __v_18: G = __r_arr[16]; + let __v_19: G = __r_arr[17]; + let __v_20: G = __r_arr[18]; + let __v_21: G = __r_arr[19]; + let __v_22: G = __r_arr[20]; + let __v_23: G = __r_arr[21]; + let __v_24: G = __r_arr[22]; + let __v_25: G = __r_arr[23]; + let __v_26: G = __r_arr[24]; + let __v_27: G = __r_arr[25]; + let __v_28: G = __r_arr[26]; + let __v_29: G = __r_arr[27]; + let __v_30: G = __r_arr[28]; + let __v_31: G = __r_arr[29]; + let __v_32: G = __r_arr[30]; + let __v_33: G = __r_arr[31]; + let __v_34: G = __r_arr[32]; + let __v_35: G = __r_arr[33]; + let __v_36: G = __r_arr[34]; + let __v_37: G = __r_arr[35]; + let __v_38: G = __r_arr[36]; + let __v_39: G = __r_arr[37]; + let __v_40: G = __r_arr[38]; + let __v_41: G = __r_arr[39]; + let __v_42: G = __r_arr[40]; + let __v_43: G = __r_arr[41]; + let __v_44: G = __r_arr[42]; + 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_106] = [__v_47, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + 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 !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_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = __r_arr[9]; + 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_106] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + 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 !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_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = __r_arr[9]; + 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_106] = [__v_13, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_14, __v_12]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + 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 !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_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = __r_arr[9]; + let __v_12: G = __r_arr[10]; + let __v_13: G = __r_arr[11]; + let __v_14: G = __r_arr[12]; + let __v_15: G = __r_arr[13]; + let __v_16: G = __r_arr[14]; + let __v_17: G = __r_arr[15]; + let __v_18: G = __r_arr[16]; + 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_106] = [__v_20, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_19]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + 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 !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]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + 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_106] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + 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 !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]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + 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_106] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + 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 !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]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + 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_106] = [__v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + record.function_queries[106].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_107: usize = 10; +const IN_107: usize = 10; +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_107], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __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_0.as_canonical_u64() { + 12u64 => { + let __r_arr: [G; OUT_105] = { let __args: [G; IN_105] = [__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[105].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_105] = unsafe { *(result.output.as_ptr() as *const [G; OUT_105]) }; __ret } else { aiur_fn_105(__args, record, io_buffer, __cu)? } }; + let __v_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_107] = [__v_12, __v_10, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_11]; + record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 13u64 => { + let __r_arr: [G; OUT_106] = { let __args: [G; IN_106] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[106].get_mut(&__args[..]) { 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]; + let __v_13: G = __r_arr[3]; + let __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + let __v_42: G = __r_arr[32]; + let __v_43: G = __r_arr[33]; + let __v_44: G = __r_arr[34]; + let __v_45: G = __r_arr[35]; + let __v_46: G = __r_arr[36]; + let __v_47: G = __r_arr[37]; + let __v_48: G = __r_arr[38]; + let __v_49: G = __r_arr[39]; + let __v_50: G = __r_arr[40]; + let __v_51: G = __r_arr[41]; + let __v_52: G = __r_arr[42]; + let __v_53: G = __r_arr[43]; + let __v_54: G = __r_arr[44]; + let __v_55: G = __r_arr[45]; + let __ret: [G; OUT_107] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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]; + record.function_queries[107].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_108: usize = 1; +const IN_108: usize = 1; +const OUT_108: usize = 49; +fn aiur_fn_108( + inp: [G; IN_108], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_108], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_75] = { let __args: [G; IN_75] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[75].get_mut(&__args[..]) { 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_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 __r_arr: [G; OUT_107] = { let __args: [G; IN_107] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[107].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_107] = unsafe { *(result.output.as_ptr() as *const [G; OUT_107]) }; __ret } else { aiur_fn_107(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_20: G = __r_arr[9]; + let __v_21: G = __r_arr[10]; + let __v_22: G = __r_arr[11]; + let __v_23: G = __r_arr[12]; + let __v_24: G = __r_arr[13]; + let __v_25: G = __r_arr[14]; + let __v_26: G = __r_arr[15]; + let __v_27: G = __r_arr[16]; + let __v_28: G = __r_arr[17]; + let __v_29: G = __r_arr[18]; + let __v_30: G = __r_arr[19]; + let __v_31: G = __r_arr[20]; + let __v_32: G = __r_arr[21]; + let __v_33: G = __r_arr[22]; + let __v_34: G = __r_arr[23]; + let __v_35: G = __r_arr[24]; + let __v_36: G = __r_arr[25]; + let __v_37: G = __r_arr[26]; + let __v_38: G = __r_arr[27]; + let __v_39: G = __r_arr[28]; + let __v_40: G = __r_arr[29]; + let __v_41: G = __r_arr[30]; + let __v_42: G = __r_arr[31]; + let __v_43: G = __r_arr[32]; + let __v_44: G = __r_arr[33]; + let __v_45: G = __r_arr[34]; + let __v_46: G = __r_arr[35]; + let __v_47: G = __r_arr[36]; + let __v_48: G = __r_arr[37]; + let __v_49: G = __r_arr[38]; + let __v_50: G = __r_arr[39]; + let __v_51: G = __r_arr[40]; + let __v_52: G = __r_arr[41]; + let __v_53: G = __r_arr[42]; + let __v_54: G = __r_arr[43]; + let __v_55: G = __r_arr[44]; + let __v_56: G = __r_arr[45]; + let __r_arr: [G; OUT_88] = { let __args: [G; IN_88] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[88].get_mut(&__args[..]) { 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_57: G = __r_arr[0]; + let __v_58: G = __r_arr[1]; + let __r_arr: [G; OUT_89] = { let __args: [G; IN_89] = [__v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[89].get_mut(&__args[..]) { 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_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __r_arr: [G; OUT_90] = { let __args: [G; IN_90] = [__v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[90].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __ret: [G; OUT_108] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_57, __v_59, __v_61, __v_62]; + record.function_queries[108].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 = 3; +fn aiur_fn_109( + inp: [G; IN_109], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_109], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_109] = [__v_10, __v_11, __v_11]; + record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_10: G = G::from_u64(1); + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_109] = [__v_10, __v_14, __v_15]; + record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_10: G = G::from_u64(2); + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_16, __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_109] = [__v_10, __v_14, __v_18]; + record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_10: G = G::from_u64(3); + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_16, __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_109] = [__v_10, __v_14, __v_18]; + record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_10: G = G::from_u64(4); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_109] = [__v_10, __v_11, __v_12]; + record.function_queries[109].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_110: usize = 2; +const IN_110: usize = 2; +const OUT_110: usize = 1; +fn aiur_fn_110( + inp: [G; IN_110], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_110], 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 __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_110] = [__v_14]; + record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_16, __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_110] = { let __args: [G; IN_110] = [__v_11, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = { let __values: [G; 3] = [__v_14, __v_18, __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_110] = [__v_20]; + record.function_queries[110].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +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_111], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(0); + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__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[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + 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_113] = { let __args: [G; IN_113] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __v_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]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__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_111] = [__v_26]; + record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(1); + let __v_26: G = G::from_u64(1); + let __v_27: G = { let __values: [G; 10] = [__v_25, __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(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 10] = [__v_24, __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_111] = [__v_28]; + record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { 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_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 10] = [__v_24, __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_111] = [__v_25]; + record.function_queries[111].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_112: usize = 10; +const IN_112: usize = 10; +const OUT_112: usize = 8; +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 __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_9.as_canonical_u64() { + 8u64 => { + let __ret: [G; OUT_112] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + 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_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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() { + 1u64 => { + let __ret: [G; OUT_112] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; + record.function_queries[112].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_112] = { let __args: [G; IN_112] = [__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[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_13: G = G::from_u64(2); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__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[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_13: G = G::from_u64(3); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__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[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_13: G = G::from_u64(4); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__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[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_13: G = G::from_u64(5); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__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[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_13: G = G::from_u64(6); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__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[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_13: G = G::from_u64(7); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__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[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(8); + let __r_arr: [G; OUT_112] = { let __args: [G; IN_112] = [__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[112].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_112] = unsafe { *(result.output.as_ptr() as *const [G; OUT_112]) }; __ret } else { aiur_fn_112(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_112] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[112].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_113: usize = 2; +const IN_113: usize = 2; +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_113], 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_113] = [__v_0]; + record.function_queries[113].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_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_113] = [__v_7]; + record.function_queries[113].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_113] = { let __args: [G; IN_113] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[113].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_113] = unsafe { *(result.output.as_ptr() as *const [G; OUT_113]) }; __ret } else { aiur_fn_113(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_113] = [__v_7]; + record.function_queries[113].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +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 __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 }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + let __v_11: G = __loaded[5]; + let __v_12: G = __loaded[6]; + let __v_13: G = __loaded[7]; + let __v_14: G = __loaded[8]; + let __v_15: G = __loaded[9]; + let __v_16: G = __loaded[10]; + let __v_17: G = __loaded[11]; + let __v_18: G = __loaded[12]; + let __v_19: G = __loaded[13]; + let __v_20: G = __loaded[14]; + let __v_21: G = __loaded[15]; + let __v_22: G = __loaded[16]; + let __v_23: G = __loaded[17]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(1); + let __r_arr: [G; OUT_109] = { let __args: [G; IN_109] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[109].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_109] = unsafe { *(result.output.as_ptr() as *const [G; OUT_109]) }; __ret } else { aiur_fn_109(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __v_29: G = __r_arr[2]; + let __v_30: G = { let __values: [G; 3] = [__v_27, __v_28, __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 __v_32: G = { let __values: [G; 4] = [__v_26, __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_114] = [__v_32]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_24: G = G::from_u64(0); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __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_114] = [__v_27]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(2); + let __v_28: G = G::from_u64(0); + let __v_29: G = { let __values: [G; 4] = [__v_27, __v_25, __v_26, __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_114] = [__v_29]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_110] = { let __args: [G; IN_110] = [__v_15, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[110].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_110] = unsafe { *(result.output.as_ptr() as *const [G; OUT_110]) }; __ret } else { aiur_fn_110(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(2); + let __v_28: G = G::from_u64(0); + let __v_29: G = { let __values: [G; 4] = [__v_27, __v_25, __v_26, __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_114] = [__v_29]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(8); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_23, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = { let __values: [G; 4] = [__v_26, __v_25, __v_27, __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_114] = [__v_29]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = G::from_u64(7); + let __v_26: G = G::from_u64(1); + let __v_27: G = G::from_u64(0); + let __v_28: G = { let __values: [G; 4] = [__v_25, __v_26, __v_24, __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_114] = [__v_28]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_4, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_111] = { let __args: [G; IN_111] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[111].get_mut(&__args[..]) { 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_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(7); + 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_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_114] = [__v_29]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_24: G = G::from_u64(3); + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(0); + let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __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_114] = [__v_28]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __v_24: G = G::from_u64(4); + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(0); + let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __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_114] = [__v_28]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 9u64 => { + let __v_24: G = G::from_u64(5); + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(0); + let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __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_114] = [__v_28]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 10u64 => { + let __v_24: G = G::from_u64(6); + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_17, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = { let __values: [G; 4] = [__v_24, __v_25, __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_114] = [__v_28]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 11u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_26: G = __loaded[0]; + let __v_27: G = __loaded[1]; + let __v_28: G = __loaded[2]; + match __v_26.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_27, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_114] = [__v_29]; + record.function_queries[114].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_26.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_115: usize = 7; +const IN_115: usize = 7; +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 __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 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 }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(1); + let __v_20: G = { let __values: [G; 5] = [__v_18, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_115] = [__v_20]; + record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_8.as_canonical_u64() { + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + match __v_18.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_16, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = G::from_u64(0); + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_17, __v_20, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = { let __values: [G; 5] = [__v_23, __v_19, __v_22, __v_21, __v_24]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_115] = [__v_25]; + record.function_queries[115].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_116: usize = 18; +const IN_116: usize = 18; +const OUT_116: usize = 11; +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]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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]; + match __v_12.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_10, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_20: G = G::from_u64(1); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + let __ret: [G; OUT_116] = [__v_20, __v_21, __v_18, __v_19, __v_1, __v_17, __v_22, __v_22, __v_22, __v_22, __v_22]; + record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_20: G = G::from_u64(3); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_116] = [__v_20, __v_21, __v_18, __v_19, __v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; + record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_20: G = G::from_u64(3); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_116] = [__v_20, __v_21, __v_18, __v_19, __v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; + record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __v_20: G = G::from_u64(2); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + let __ret: [G; OUT_116] = [__v_20, __v_21, __v_18, __v_19, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22, __v_22]; + record.function_queries[116].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_117: usize = 15; +const IN_117: usize = 15; +const OUT_117: usize = 11; +fn aiur_fn_117( + inp: [G; IN_117], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_117], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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]; + match __v_10.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_117] = [__v_16, __v_17, __v_15, __v_0, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; + record.function_queries[117].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_118: usize = 15; +const IN_118: usize = 15; +const OUT_118: usize = 11; +fn aiur_fn_118( + inp: [G; IN_118], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_118], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __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]; + match __v_10.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(4); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_118] = [__v_16, __v_17, __v_15, __v_0, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18]; + record.function_queries[118].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_119: usize = 51; +const IN_119: usize = 51; +const OUT_119: usize = 11; +fn aiur_fn_119( + inp: [G; IN_119], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_119], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + match __v_44.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_42, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __r_arr: [G; OUT_115] = { let __args: [G; IN_115] = [__v_43, __v_49, __v_44, __v_45, __v_46, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[115].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_115] = unsafe { *(result.output.as_ptr() as *const [G; OUT_115]) }; __ret } else { aiur_fn_115(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __v_53: G = G::from_u64(7); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + 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 !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_56: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __ret: [G; OUT_119] = [__v_53, __v_54, __v_51, __v_55, __v_56, __v_57, __v_58, __v_52, __v_0, __v_1, __v_50]; + record.function_queries[119].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_120: usize = 44; +const IN_120: usize = 44; +const OUT_120: usize = 11; +fn aiur_fn_120( + inp: [G; IN_120], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_120], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + match __v_37.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_35, __v_37, __v_38, __v_39, __v_40, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = G::from_u64(5); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __ret: [G; OUT_120] = [__v_45, __v_46, __v_44, __v_47, __v_48, __v_42, __v_0, __v_1, __v_2, __v_49, __v_43]; + record.function_queries[120].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_121: usize = 40; +const IN_121: usize = 40; +const OUT_121: usize = 11; +fn aiur_fn_121( + inp: [G; IN_121], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_121], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + match __v_34.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_114] = { let __args: [G; IN_114] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[114].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_114] = unsafe { *(result.output.as_ptr() as *const [G; OUT_114]) }; __ret } else { aiur_fn_114(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __v_41: G = G::from_u64(6); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(0); + let __ret: [G; OUT_121] = [__v_41, __v_42, __v_40, __v_39, __v_43, __v_44, __v_45, __v_0, __v_46, __v_46, __v_46]; + record.function_queries[121].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 = 11; +fn aiur_fn_122( + inp: [G; IN_122], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_122], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 52] = { let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 52 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 52] = __args[..52].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + let __v_48: G = __loaded[47]; + let __v_49: G = __loaded[48]; + let __v_50: G = __loaded[49]; + let __v_51: G = __loaded[50]; + let __v_52: G = __loaded[51]; + match __v_1.as_canonical_u64() { + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_116] = { let __args: [G; IN_116] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_1, __v_2, __v_3, __v_4, __v_5, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[116].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_116] = unsafe { *(result.output.as_ptr() as *const [G; OUT_116]) }; __ret } else { aiur_fn_116(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __v_55: G = __r_arr[2]; + let __v_56: G = __r_arr[3]; + let __v_57: G = __r_arr[4]; + let __v_58: G = __r_arr[5]; + let __v_59: G = __r_arr[6]; + let __v_60: G = __r_arr[7]; + let __v_61: G = __r_arr[8]; + let __v_62: G = __r_arr[9]; + let __v_63: G = __r_arr[10]; + let __ret: [G; OUT_122] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_117] = { let __args: [G; IN_117] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[117].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_117] = unsafe { *(result.output.as_ptr() as *const [G; OUT_117]) }; __ret } else { aiur_fn_117(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __v_55: G = __r_arr[2]; + let __v_56: G = __r_arr[3]; + let __v_57: G = __r_arr[4]; + let __v_58: G = __r_arr[5]; + let __v_59: G = __r_arr[6]; + let __v_60: G = __r_arr[7]; + let __v_61: G = __r_arr[8]; + let __v_62: G = __r_arr[9]; + let __v_63: G = __r_arr[10]; + let __ret: [G; OUT_122] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_118] = { let __args: [G; IN_118] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[118].get_mut(&__args[..]) { 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_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __v_55: G = __r_arr[2]; + let __v_56: G = __r_arr[3]; + let __v_57: G = __r_arr[4]; + let __v_58: G = __r_arr[5]; + let __v_59: G = __r_arr[6]; + let __v_60: G = __r_arr[7]; + let __v_61: G = __r_arr[8]; + let __v_62: G = __r_arr[9]; + let __v_63: G = __r_arr[10]; + let __ret: [G; OUT_122] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_119] = { let __args: [G; IN_119] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_1, __v_2, __v_3, __v_4, __v_5, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[119].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_119] = unsafe { *(result.output.as_ptr() as *const [G; OUT_119]) }; __ret } else { aiur_fn_119(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __v_55: G = __r_arr[2]; + let __v_56: G = __r_arr[3]; + let __v_57: G = __r_arr[4]; + let __v_58: G = __r_arr[5]; + let __v_59: G = __r_arr[6]; + let __v_60: G = __r_arr[7]; + let __v_61: G = __r_arr[8]; + let __v_62: G = __r_arr[9]; + let __v_63: G = __r_arr[10]; + let __ret: [G; OUT_122] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_120] = { let __args: [G; IN_120] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_1, __v_2, __v_3, __v_4, __v_5, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[120].get_mut(&__args[..]) { 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_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __v_55: G = __r_arr[2]; + let __v_56: G = __r_arr[3]; + let __v_57: G = __r_arr[4]; + let __v_58: G = __r_arr[5]; + let __v_59: G = __r_arr[6]; + let __v_60: G = __r_arr[7]; + let __v_61: G = __r_arr[8]; + let __v_62: G = __r_arr[9]; + let __v_63: G = __r_arr[10]; + let __ret: [G; OUT_122] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_121] = { let __args: [G; IN_121] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_1, __v_2, __v_3, __v_4, __v_5, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[121].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_121] = unsafe { *(result.output.as_ptr() as *const [G; OUT_121]) }; __ret } else { aiur_fn_121(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __v_55: G = __r_arr[2]; + let __v_56: G = __r_arr[3]; + let __v_57: G = __r_arr[4]; + let __v_58: G = __r_arr[5]; + let __v_59: G = __r_arr[6]; + let __v_60: G = __r_arr[7]; + let __v_61: G = __r_arr[8]; + let __v_62: G = __r_arr[9]; + let __v_63: G = __r_arr[10]; + let __ret: [G; OUT_122] = [__v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[122].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_123: usize = 1; +const IN_123: usize = 1; +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_123], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_123] = [__v_6]; + 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_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[122].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_122] = unsafe { *(result.output.as_ptr() as *const [G; OUT_122]) }; __ret } else { aiur_fn_122(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __v_6: G = __r_arr[2]; + let __v_7: G = __r_arr[3]; + let __v_8: G = __r_arr[4]; + let __v_9: G = __r_arr[5]; + let __v_10: G = __r_arr[6]; + let __v_11: G = __r_arr[7]; + let __v_12: G = __r_arr[8]; + let __v_13: G = __r_arr[9]; + let __v_14: G = __r_arr[10]; + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 11] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; 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 __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = { let __values: [G; 3] = [__v_15, __v_16, __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_123] = [__v_18]; + record.function_queries[123].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_124: usize = 1; +const IN_124: usize = 1; +const OUT_124: usize = 48; +fn aiur_fn_124( + inp: [G; IN_124], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_124], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = G::from_u64(2); + let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_34: G = __io_pair.0; + let __v_35: G = __io_pair.1; + let __v_36: G = G::from_u64(2); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __v_40: G = __r_arr[2]; + let __v_41: G = __r_arr[3]; + let __v_42: G = __r_arr[4]; + let __v_43: G = __r_arr[5]; + let __v_44: G = __r_arr[6]; + let __v_45: G = __r_arr[7]; + let __v_46: G = __r_arr[8]; + let __v_47: G = __r_arr[9]; + let __v_48: G = __r_arr[10]; + let __v_49: G = __r_arr[11]; + let __v_50: G = __r_arr[12]; + let __v_51: G = __r_arr[13]; + let __v_52: G = __r_arr[14]; + let __v_53: G = __r_arr[15]; + let __v_54: G = __r_arr[16]; + let __v_55: G = __r_arr[17]; + let __v_56: G = __r_arr[18]; + let __v_57: G = __r_arr[19]; + let __v_58: G = __r_arr[20]; + let __v_59: G = __r_arr[21]; + let __v_60: G = __r_arr[22]; + let __v_61: G = __r_arr[23]; + let __v_62: G = __r_arr[24]; + let __v_63: G = __r_arr[25]; + let __v_64: G = __r_arr[26]; + let __v_65: G = __r_arr[27]; + let __v_66: G = __r_arr[28]; + let __v_67: G = __r_arr[29]; + let __v_68: G = __r_arr[30]; + let __v_69: G = __r_arr[31]; + let __v_70: G = __r_arr[32]; + let __v_71: G = __r_arr[33]; + let __v_72: G = __r_arr[34]; + let __v_73: G = __r_arr[35]; + let __v_74: G = __r_arr[36]; + let __v_75: G = __r_arr[37]; + let __v_76: G = __r_arr[38]; + let __v_77: G = __r_arr[39]; + let __v_78: G = __r_arr[40]; + let __v_79: G = __r_arr[41]; + let __v_80: G = __r_arr[42]; + let __v_81: G = __r_arr[43]; + let __v_82: G = __r_arr[44]; + let __v_83: G = __r_arr[45]; + let __v_84: G = __r_arr[46]; + let __v_85: G = __r_arr[47]; + let __v_86: G = __r_arr[48]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_86.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_87: G = __loaded[0]; + let __v_88: G = __loaded[1]; + let __v_89: G = __loaded[2]; + let __v_90: G = G::from_u64(1); + let __v_91: G = G::from_u64(1); + if (__v_87 != __v_90) { + return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_90.as_canonical_u64() }); + } + if (__v_88 != __v_91) { + return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_91.as_canonical_u64() }); + } + if (__v_89 != __v_91) { + return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_91.as_canonical_u64() }); + } + let __ret: [G; OUT_124] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85]; + record.function_queries[124].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_125: usize = 1; +const IN_125: usize = 1; +const OUT_125: usize = 1; +fn aiur_fn_125( + inp: [G; IN_125], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_125], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = G::from_u64(5); + let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_34: G = __io_pair.0; + let __v_35: G = __io_pair.1; + let __v_36: G = G::from_u64(5); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __ret: [G; OUT_125] = [__v_37]; + record.function_queries[125].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_126], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_34: G = __loaded[0]; + let __v_35: G = __loaded[1]; + let __v_36: G = __loaded[2]; + let __v_37: G = __loaded[3]; + let __v_38: G = __loaded[4]; + let __v_39: G = __loaded[5]; + let __v_40: G = __loaded[6]; + let __v_41: G = __loaded[7]; + let __v_42: G = __loaded[8]; + let __v_43: G = __loaded[9]; + let __v_44: G = __loaded[10]; + let __v_45: G = __loaded[11]; + let __v_46: G = __loaded[12]; + let __v_47: G = __loaded[13]; + let __v_48: G = __loaded[14]; + let __v_49: G = __loaded[15]; + let __v_50: G = __loaded[16]; + let __v_51: G = __loaded[17]; + let __v_52: G = __loaded[18]; + let __v_53: G = __loaded[19]; + let __v_54: G = __loaded[20]; + let __v_55: G = __loaded[21]; + let __v_56: G = __loaded[22]; + let __v_57: G = __loaded[23]; + let __v_58: G = __loaded[24]; + let __v_59: G = __loaded[25]; + let __v_60: G = __loaded[26]; + let __v_61: G = __loaded[27]; + let __v_62: G = __loaded[28]; + let __v_63: G = __loaded[29]; + let __v_64: G = __loaded[30]; + let __v_65: G = __loaded[31]; + let __v_66: G = (__v_3 - __v_35); + let __v_67: G = (__v_4 - __v_36); + let __v_68: G = (__v_5 - __v_37); + let __v_69: G = (__v_6 - __v_38); + let __v_70: G = (__v_7 - __v_39); + let __v_71: G = (__v_8 - __v_40); + let __v_72: G = (__v_9 - __v_41); + let __v_73: G = (__v_10 - __v_42); + let __v_74: G = (__v_11 - __v_43); + let __v_75: G = (__v_12 - __v_44); + let __v_76: G = (__v_13 - __v_45); + let __v_77: G = (__v_14 - __v_46); + let __v_78: G = (__v_15 - __v_47); + let __v_79: G = (__v_16 - __v_48); + let __v_80: G = (__v_17 - __v_49); + let __v_81: G = (__v_18 - __v_50); + let __v_82: G = (__v_19 - __v_51); + let __v_83: G = (__v_20 - __v_52); + let __v_84: G = (__v_21 - __v_53); + let __v_85: G = (__v_22 - __v_54); + let __v_86: G = (__v_23 - __v_55); + let __v_87: G = (__v_24 - __v_56); + let __v_88: G = (__v_25 - __v_57); + let __v_89: G = (__v_26 - __v_58); + let __v_90: G = (__v_27 - __v_59); + let __v_91: G = (__v_28 - __v_60); + let __v_92: G = (__v_29 - __v_61); + let __v_93: G = (__v_30 - __v_62); + let __v_94: G = (__v_31 - __v_63); + let __v_95: G = (__v_32 - __v_64); + let __v_96: G = (__v_33 - __v_65); + match __v_66.as_canonical_u64() { + 0u64 => { + match __v_67.as_canonical_u64() { + 0u64 => { + match __v_68.as_canonical_u64() { + 0u64 => { + match __v_69.as_canonical_u64() { + 0u64 => { + match __v_70.as_canonical_u64() { + 0u64 => { + match __v_71.as_canonical_u64() { + 0u64 => { + match __v_72.as_canonical_u64() { + 0u64 => { + match __v_73.as_canonical_u64() { + 0u64 => { + match __v_74.as_canonical_u64() { + 0u64 => { + match __v_75.as_canonical_u64() { + 0u64 => { + match __v_76.as_canonical_u64() { + 0u64 => { + match __v_77.as_canonical_u64() { + 0u64 => { + match __v_78.as_canonical_u64() { + 0u64 => { + match __v_79.as_canonical_u64() { + 0u64 => { + match __v_80.as_canonical_u64() { + 0u64 => { + match __v_81.as_canonical_u64() { + 0u64 => { + match __v_82.as_canonical_u64() { + 0u64 => { + match __v_83.as_canonical_u64() { + 0u64 => { + match __v_84.as_canonical_u64() { + 0u64 => { + match __v_85.as_canonical_u64() { + 0u64 => { + match __v_86.as_canonical_u64() { + 0u64 => { + match __v_87.as_canonical_u64() { + 0u64 => { + match __v_88.as_canonical_u64() { + 0u64 => { + match __v_89.as_canonical_u64() { + 0u64 => { + match __v_90.as_canonical_u64() { + 0u64 => { + match __v_91.as_canonical_u64() { + 0u64 => { + match __v_92.as_canonical_u64() { + 0u64 => { + match __v_93.as_canonical_u64() { + 0u64 => { + match __v_94.as_canonical_u64() { + 0u64 => { + match __v_95.as_canonical_u64() { + 0u64 => { + match __v_96.as_canonical_u64() { + 0u64 => { + let __v_97: G = G::from_u64(1); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_97: G = G::from_u64(0); + let __ret: [G; OUT_126] = [__v_97]; + record.function_queries[126].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_127: usize = 2; +const IN_127: usize = 2; +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_127], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_34: G = __loaded[0]; + let __v_35: G = __loaded[1]; + let __v_36: G = __loaded[2]; + let __v_37: G = __loaded[3]; + let __v_38: G = __loaded[4]; + let __v_39: G = __loaded[5]; + let __v_40: G = __loaded[6]; + let __v_41: G = __loaded[7]; + let __v_42: G = __loaded[8]; + let __v_43: G = __loaded[9]; + let __v_44: G = __loaded[10]; + let __v_45: G = __loaded[11]; + let __v_46: G = __loaded[12]; + let __v_47: G = __loaded[13]; + let __v_48: G = __loaded[14]; + let __v_49: G = __loaded[15]; + let __v_50: G = __loaded[16]; + let __v_51: G = __loaded[17]; + let __v_52: G = __loaded[18]; + let __v_53: G = __loaded[19]; + let __v_54: G = __loaded[20]; + let __v_55: G = __loaded[21]; + let __v_56: G = __loaded[22]; + let __v_57: G = __loaded[23]; + let __v_58: G = __loaded[24]; + let __v_59: G = __loaded[25]; + let __v_60: G = __loaded[26]; + let __v_61: G = __loaded[27]; + let __v_62: G = __loaded[28]; + let __v_63: G = __loaded[29]; + let __v_64: G = __loaded[30]; + let __v_65: G = __loaded[31]; + let __v_66: G = (__v_2 - __v_34); + match __v_66.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_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 !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_67: G = __r_arr[0]; + let __ret: [G; OUT_127] = [__v_67]; + record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_67: G = G::from_u64(0); + let __ret: [G; OUT_127] = [__v_67]; + record.function_queries[127].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_128: usize = 1; +const IN_128: usize = 1; +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_128], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = G::from_u64(3); + let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_34: G = __io_pair.0; + let __v_35: G = __io_pair.1; + let __v_36: G = G::from_u64(3); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_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]; + let __v_39: G = __loaded[1]; + let __v_40: G = __loaded[2]; + match __v_38.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_128] = [__v_39]; + record.function_queries[128].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_38.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_129: usize = 0; +const IN_129: usize = 0; +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_129], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(4294967295); + let __ret: [G; OUT_129] = [__v_0]; + record.function_queries[129].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_130: usize = 45; +const IN_130: usize = 45; +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_130], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + match __v_0.as_canonical_u64() { + 6u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __ret: [G; OUT_130] = [__v_9]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __ret: [G; OUT_130] = [__v_17]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 5u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __ret: [G; OUT_130] = [__v_9]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 7u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __ret: [G; OUT_130] = [__v_9]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_130] = [__v_77]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_130] = [__v_77]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_130] = [__v_77]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_130] = [__v_77]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_130] = [__v_77]; + record.function_queries[130].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_131: usize = 45; +const IN_131: usize = 45; +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_131], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + match __v_0.as_canonical_u64() { + 1u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(1); + let __v_47: G = (__v_45 + __v_46); + let __ret: [G; OUT_131] = [__v_47]; + record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __v_45: G = G::from_u64(1); + let __ret: [G; OUT_131] = [__v_45]; + record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_45: G = G::from_u64(1); + let __ret: [G; OUT_131] = [__v_45]; + record.function_queries[131].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_132: usize = 1; +const IN_132: usize = 1; +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_132], 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(0); + let __ret: [G; OUT_132] = [__v_48]; + record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { 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_48: G = __r_arr[0]; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = (__v_48 + __v_49); + let __ret: [G; OUT_132] = [__v_50]; + record.function_queries[132].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +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_133], 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_133] = [__v_2]; + record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + 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 }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + let __v_38: G = __loaded[36]; + let __v_39: G = __loaded[37]; + let __v_40: G = __loaded[38]; + let __v_41: G = __loaded[39]; + let __v_42: G = __loaded[40]; + let __v_43: G = __loaded[41]; + let __v_44: G = __loaded[42]; + let __v_45: G = __loaded[43]; + let __v_46: G = __loaded[44]; + let __v_47: G = __loaded[45]; + let __v_48: G = __loaded[46]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __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[131].get_mut(&__args[..]) { 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_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(1); + let __v_51: G = (__v_1 - __v_50); + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { 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_52: G = __r_arr[0]; + let __v_53: G = (__v_49 + __v_52); + let __ret: [G; OUT_133] = [__v_53]; + record.function_queries[133].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_134: usize = 4; +const IN_134: usize = 4; +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_134], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __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_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_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]; + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_134] = [__v_12]; + record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4294967295u64 => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_134] = [__v_12]; + record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_11 - __v_12); + let __ret: [G; OUT_134] = [__v_13]; + record.function_queries[134].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_135: usize = 3; +const IN_135: usize = 3; +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_135], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_135] = [__v_6]; + record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_135] = [__v_7]; + record.function_queries[135].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_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_135] = [__v_10]; + record.function_queries[135].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_136: usize = 2; +const IN_136: usize = 2; +const OUT_136: usize = 6; +fn aiur_fn_136( + inp: [G; IN_136], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_136], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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 __ret: [G; OUT_136] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6]; + record.function_queries[136].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() { + 0u64 => { + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_6 + __v_8); + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_3, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __v_19: G = __r_arr[3]; + let __v_20: G = __r_arr[4]; + let __v_21: G = __r_arr[5]; + let __ret: [G; OUT_136] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; + record.function_queries[136].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_137: usize = 7; +const IN_137: usize = 7; +const OUT_137: usize = 6; +fn aiur_fn_137( + inp: [G; IN_137], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_137], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_137] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; 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: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].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]; + let __v_20: G = __loaded[10]; + let __v_21: G = __loaded[11]; + let __v_22: G = __loaded[12]; + let __v_23: G = __loaded[13]; + let __v_24: G = __loaded[14]; + let __v_25: G = __loaded[15]; + let __v_26: G = __loaded[16]; + let __v_27: G = __loaded[17]; + let __v_28: G = __loaded[18]; + let __v_29: G = __loaded[19]; + let __v_30: G = __loaded[20]; + let __v_31: G = __loaded[21]; + let __v_32: G = __loaded[22]; + let __v_33: G = __loaded[23]; + let __v_34: G = __loaded[24]; + let __v_35: G = __loaded[25]; + let __v_36: G = __loaded[26]; + let __v_37: G = __loaded[27]; + let __v_38: G = __loaded[28]; + let __v_39: G = __loaded[29]; + let __v_40: G = __loaded[30]; + let __v_41: G = __loaded[31]; + let __v_42: G = __loaded[32]; + let __v_43: G = __loaded[33]; + let __v_44: G = __loaded[34]; + let __v_45: G = __loaded[35]; + let __v_46: G = __loaded[36]; + let __v_47: G = __loaded[37]; + let __v_48: G = __loaded[38]; + let __v_49: G = __loaded[39]; + let __v_50: G = __loaded[40]; + let __v_51: G = __loaded[41]; + let __v_52: G = __loaded[42]; + let __v_53: G = __loaded[43]; + let __v_54: G = __loaded[44]; + let __v_55: G = __loaded[45]; + let __v_56: G = __loaded[46]; + let __v_57: G = __loaded[47]; + match __v_10.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_56, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { 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_58: G = __r_arr[0]; + let __v_59: G = __r_arr[1]; + let __v_60: G = __r_arr[2]; + let __v_61: G = __r_arr[3]; + let __v_62: G = __r_arr[4]; + let __v_63: G = __r_arr[5]; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_9, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = __r_arr[1]; + let __v_66: G = __r_arr[2]; + let __v_67: G = __r_arr[3]; + let __v_68: G = __r_arr[4]; + let __v_69: G = __r_arr[5]; + let __ret: [G; OUT_137] = [__v_64, __v_65, __v_66, __v_67, __v_68, __v_69]; + record.function_queries[137].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_138: usize = 7; +const IN_138: usize = 7; +const OUT_138: usize = 6; +fn aiur_fn_138( + inp: [G; IN_138], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_138], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_138] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_129] = { let __args: [G; IN_129] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[129].get_mut(&__args[..]) { 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_12: G = __r_arr[0]; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_8, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __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 __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_9, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { 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_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 __ret: [G; OUT_138] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24]; + record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_138] = { let __args: [G; IN_138] = [__v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[138].get_mut(&__args[..]) { 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_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 __ret: [G; OUT_138] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; + record.function_queries[138].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_139: usize = 2; +const IN_139: usize = 2; +const OUT_139: usize = 6; +fn aiur_fn_139( + inp: [G; IN_139], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_139], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_0, __v_1, __v_2, __v_3, __v_3, __v_3, __v_3, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __v_6: G = __r_arr[2]; + let __v_7: G = __r_arr[3]; + let __v_8: G = __r_arr[4]; + let __v_9: G = __r_arr[5]; + let __ret: [G; OUT_139] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; + record.function_queries[139].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_140: usize = 8; +const IN_140: usize = 8; +const OUT_140: usize = 6; +fn aiur_fn_140( + inp: [G; IN_140], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_140], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_140] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; + record.function_queries[140].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_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_9, __v_12, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __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 __r_arr: [G; OUT_140] = { let __args: [G; IN_140] = [__v_10, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[140].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_140] = unsafe { *(result.output.as_ptr() as *const [G; OUT_140]) }; __ret } else { aiur_fn_140(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + let __ret: [G; OUT_140] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25]; + record.function_queries[140].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }) +} + +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_141], 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_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_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 = G::from_u64(0); + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_141] = [__v_9]; + record.function_queries[141].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +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_142], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_142] = [__v_5]; + record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = (__v_3 - __v_0); + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_142] = [__v_6]; + record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { 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_6: G = __r_arr[0]; + let __ret: [G; OUT_142] = [__v_6]; + record.function_queries[142].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_143: usize = 48; +const IN_143: usize = 48; +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_143], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + match __v_0.as_canonical_u64() { + _ => { + match __v_0.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { 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_48: G = __r_arr[0]; + match __v_48.as_canonical_u64() { + 0u64 => { + let __v_49: G = G::from_u64(0); + let __ret: [G; OUT_143] = [__v_49]; + record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_49: G = { let __values: [G; 48] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_49]; + record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_48.as_canonical_u64())); + }, + } + }, + _ => { + let __v_48: G = G::from_u64(0); + let __ret: [G; OUT_143] = [__v_48]; + record.function_queries[143].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_144: usize = 1; +const IN_144: usize = 1; +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 = 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_47.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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 }; + let __v_48: G = __loaded[0]; + let __v_49: G = __loaded[1]; + let __v_50: G = __loaded[2]; + let __v_51: G = __loaded[3]; + let __v_52: G = __loaded[4]; + let __v_53: G = __loaded[5]; + let __v_54: G = __loaded[6]; + let __v_55: G = __loaded[7]; + let __v_56: G = __loaded[8]; + let __v_57: G = __loaded[9]; + let __v_58: G = __loaded[10]; + let __v_59: G = __loaded[11]; + let __v_60: G = __loaded[12]; + let __v_61: G = __loaded[13]; + let __v_62: G = __loaded[14]; + let __v_63: G = __loaded[15]; + let __v_64: G = __loaded[16]; + let __v_65: G = __loaded[17]; + let __v_66: G = __loaded[18]; + let __v_67: G = __loaded[19]; + let __v_68: G = __loaded[20]; + let __v_69: G = __loaded[21]; + let __v_70: G = __loaded[22]; + let __v_71: G = __loaded[23]; + let __v_72: G = __loaded[24]; + let __v_73: G = __loaded[25]; + let __v_74: G = __loaded[26]; + let __v_75: G = __loaded[27]; + let __v_76: G = __loaded[28]; + let __v_77: G = __loaded[29]; + let __v_78: G = __loaded[30]; + let __v_79: G = __loaded[31]; + let __v_80: G = __loaded[32]; + let __v_81: G = __loaded[33]; + let __v_82: G = __loaded[34]; + let __v_83: G = __loaded[35]; + let __v_84: G = __loaded[36]; + let __v_85: G = __loaded[37]; + let __v_86: G = __loaded[38]; + let __v_87: G = __loaded[39]; + let __v_88: G = __loaded[40]; + let __v_89: G = __loaded[41]; + let __v_90: G = __loaded[42]; + let __v_91: G = __loaded[43]; + let __v_92: G = __loaded[44]; + let __v_93: G = __loaded[45]; + let __v_94: G = __loaded[46]; + match __v_48.as_canonical_u64() { + 1u64 => { + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_95: G = G::from_u64(1); + let __ret: [G; OUT_144] = [__v_95]; + record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_95: G = G::from_u64(0); + let __ret: [G; OUT_144] = [__v_95]; + record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_95: G = G::from_u64(0); + let __ret: [G; OUT_144] = [__v_95]; + record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_48: G = G::from_u64(0); + let __ret: [G; OUT_144] = [__v_48]; + record.function_queries[144].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_145: usize = 3; +const IN_145: usize = 3; +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 = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_145] = [__v_6]; + record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_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 = (__v_4 - __v_0); + match __v_9.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_145] = [__v_7]; + record.function_queries[145].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { 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_10: G = __r_arr[0]; + let __ret: [G; OUT_145] = [__v_10]; + record.function_queries[145].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_146: usize = 3; +const IN_146: usize = 3; +const OUT_146: usize = 3; +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 = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(1); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __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_147] = { let __args: [G; IN_147] = [__v_0, __v_1, __v_2, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { 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 __v_10: G = __r_arr[1]; + let __v_11: G = __r_arr[2]; + let __ret: [G; OUT_146] = [__v_9, __v_10, __v_11]; + record.function_queries[146].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_147: usize = 5; +const IN_147: usize = 5; +const OUT_147: usize = 3; +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]; + let __v_4: G = inp[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(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(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_147] = [__v_10, __v_13, __v_2]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; 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: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __v_14: G = __loaded[6]; + let __v_15: G = __loaded[7]; + let __v_16: G = __loaded[8]; + let __v_17: G = __loaded[9]; + let __v_18: G = __loaded[10]; + let __v_19: G = __loaded[11]; + let __v_20: G = __loaded[12]; + let __v_21: G = __loaded[13]; + let __v_22: G = __loaded[14]; + let __v_23: G = __loaded[15]; + let __v_24: G = __loaded[16]; + let __v_25: G = __loaded[17]; + let __v_26: G = __loaded[18]; + let __v_27: G = __loaded[19]; + let __v_28: G = __loaded[20]; + let __v_29: G = __loaded[21]; + let __v_30: G = __loaded[22]; + let __v_31: G = __loaded[23]; + let __v_32: G = __loaded[24]; + let __v_33: G = __loaded[25]; + let __v_34: G = __loaded[26]; + let __v_35: G = __loaded[27]; + let __v_36: G = __loaded[28]; + let __v_37: G = __loaded[29]; + let __v_38: G = __loaded[30]; + let __v_39: G = __loaded[31]; + let __v_40: G = __loaded[32]; + let __v_41: G = __loaded[33]; + let __v_42: G = __loaded[34]; + let __v_43: G = __loaded[35]; + let __v_44: G = __loaded[36]; + let __v_45: G = __loaded[37]; + let __v_46: G = __loaded[38]; + let __v_47: G = __loaded[39]; + let __v_48: G = __loaded[40]; + let __v_49: G = __loaded[41]; + let __v_50: G = __loaded[42]; + let __v_51: G = __loaded[43]; + let __v_52: G = __loaded[44]; + let __v_53: G = __loaded[45]; + let __v_54: G = __loaded[46]; + let __v_55: G = __loaded[47]; + 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_56: G = __loaded[0]; + let __v_57: G = __loaded[1]; + let __v_58: G = __loaded[2]; + match __v_56.as_canonical_u64() { + 0u64 => { + match __v_8.as_canonical_u64() { + _ => { + match __v_8.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { 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_59: G = __r_arr[0]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_59.as_canonical_u64() { + 0u64 => { + let __v_60: G = G::from_u64(0); + break '__mc_0 [__v_60]; + }, + _ => { + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_59, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { 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_60: G = __r_arr[0]; + break '__mc_0 [__v_60]; + }, +} + }; + let __v_60: G = __mc_out___mc_0[0]; + match __v_60.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_59, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __v_64: G = __r_arr[2]; + let __v_65: G = G::from_u64(0); + let __v_66: G = { let __values: [G; 3] = [__v_65, __v_57, __v_62]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = G::from_u64(0); + let __v_68: G = { let __values: [G; 3] = [__v_67, __v_61, __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 __ret: [G; OUT_147] = [__v_66, __v_68, __v_64]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_59.as_canonical_u64() { + 0u64 => { + break '__mc_1 [__v_3]; + }, + _ => { + let __v_62: G = G::from_u64(0); + let __v_63: G = { let __values: [G; 3] = [__v_62, __v_59, __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 } }; + break '__mc_1 [__v_63]; + }, +} + }; + let __v_62: G = __mc_out___mc_1[0]; + let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_59.as_canonical_u64() { + 0u64 => { + break '__mc_2 [__v_4]; + }, + _ => { + let __v_63: G = G::from_u64(0); + let __v_64: G = { let __values: [G; 3] = [__v_63, __v_2, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_2 [__v_64]; + }, +} + }; + let __v_63: G = __mc_out___mc_2[0]; + let __v_64: G = (__v_2 + __v_61); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_64, __v_62, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { 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_65: G = __r_arr[0]; + let __v_66: G = __r_arr[1]; + let __v_67: G = __r_arr[2]; + let __v_68: G = G::from_u64(0); + let __v_69: G = { let __values: [G; 3] = [__v_68, __v_57, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 3] = [__v_70, __v_2, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_147] = [__v_69, __v_71, __v_67]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_60.as_canonical_u64())); + }, + } + }, + 6u64 => { + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { 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_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __v_61: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_59, __v_60, __v_61]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { 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_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __v_61: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_59, __v_60, __v_61]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { 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_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __v_61: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_59, __v_60, __v_61]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { 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_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __v_61: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_59, __v_60, __v_61]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_59: G = G::from_u64(1); + let __v_60: G = (__v_2 + __v_59); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_61, __v_62, __v_63]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_59: G = G::from_u64(1); + let __v_60: G = (__v_2 + __v_59); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_61, __v_62, __v_63]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_59: G = G::from_u64(1); + let __v_60: G = (__v_2 + __v_59); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_61, __v_62, __v_63]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_59: G = G::from_u64(1); + let __v_60: G = (__v_2 + __v_59); + let __r_arr: [G; OUT_147] = { let __args: [G; IN_147] = [__v_7, __v_58, __v_60, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[147].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __ret: [G; OUT_147] = [__v_61, __v_62, __v_63]; + record.function_queries[147].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_56.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +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_148], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = 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(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_149] = { let __args: [G; IN_149] = [__v_0, __v_1, __v_2, __v_3, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_148] = [__v_10]; + record.function_queries[148].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_149: usize = 6; +const IN_149: usize = 6; +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 __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_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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() { + 1u64 => { + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_11]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; 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: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __v_20: G = __loaded[11]; + let __v_21: G = __loaded[12]; + let __v_22: G = __loaded[13]; + let __v_23: G = __loaded[14]; + let __v_24: G = __loaded[15]; + let __v_25: G = __loaded[16]; + let __v_26: G = __loaded[17]; + let __v_27: G = __loaded[18]; + let __v_28: G = __loaded[19]; + let __v_29: G = __loaded[20]; + let __v_30: G = __loaded[21]; + let __v_31: G = __loaded[22]; + let __v_32: G = __loaded[23]; + let __v_33: G = __loaded[24]; + let __v_34: G = __loaded[25]; + let __v_35: G = __loaded[26]; + let __v_36: G = __loaded[27]; + let __v_37: G = __loaded[28]; + let __v_38: G = __loaded[29]; + let __v_39: G = __loaded[30]; + let __v_40: G = __loaded[31]; + let __v_41: G = __loaded[32]; + let __v_42: G = __loaded[33]; + let __v_43: G = __loaded[34]; + let __v_44: G = __loaded[35]; + let __v_45: G = __loaded[36]; + let __v_46: G = __loaded[37]; + let __v_47: G = __loaded[38]; + let __v_48: G = __loaded[39]; + let __v_49: G = __loaded[40]; + let __v_50: G = __loaded[41]; + let __v_51: G = __loaded[42]; + let __v_52: G = __loaded[43]; + let __v_53: G = __loaded[44]; + let __v_54: G = __loaded[45]; + let __v_55: G = __loaded[46]; + let __v_56: G = __loaded[47]; + 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_57: G = __loaded[0]; + let __v_58: G = __loaded[1]; + let __v_59: G = __loaded[2]; + match __v_57.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + _ => { + match __v_9.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { 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_60: G = __r_arr[0]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_60.as_canonical_u64() { + 0u64 => { + let __v_61: G = G::from_u64(0); + break '__mc_0 [__v_61]; + }, + _ => { + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_60, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + break '__mc_0 [__v_61]; + }, +} + }; + let __v_61: G = __mc_out___mc_0[0]; + match __v_61.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_145] = { let __args: [G; IN_145] = [__v_60, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[145].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __v_63: G = G::from_u64(0); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = { let __values: [G; 3] = [__v_63, __v_62, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_65]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_60.as_canonical_u64() { + 0u64 => { + break '__mc_1 [__v_4]; + }, + _ => { + let __v_63: G = G::from_u64(0); + let __v_64: G = { let __values: [G; 3] = [__v_63, __v_60, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_1 [__v_64]; + }, +} + }; + let __v_63: G = __mc_out___mc_1[0]; + let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_60.as_canonical_u64() { + 0u64 => { + break '__mc_2 [__v_5]; + }, + _ => { + let __v_64: G = G::from_u64(0); + let __v_65: G = { let __values: [G; 3] = [__v_64, __v_3, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_2 [__v_65]; + }, +} + }; + let __v_64: G = __mc_out___mc_2[0]; + let __v_65: G = G::from_u64(0); + let __v_66: G = (__v_3 + __v_62); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_66, __v_63, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __v_68: G = { let __values: [G; 3] = [__v_65, __v_3, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_68]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); + }, + } + }, + 6u64 => { + match __v_10.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __v_64: G = __r_arr[3]; + let __v_65: G = __r_arr[4]; + let __v_66: G = __r_arr[5]; + let __v_67: G = __r_arr[6]; + let __v_68: G = __r_arr[7]; + let __v_69: G = __r_arr[8]; + let __v_70: G = __r_arr[9]; + let __v_71: G = __r_arr[10]; + let __v_72: G = __r_arr[11]; + let __v_73: G = __r_arr[12]; + let __v_74: G = __r_arr[13]; + let __v_75: G = __r_arr[14]; + let __v_76: G = __r_arr[15]; + let __v_77: G = __r_arr[16]; + let __v_78: G = __r_arr[17]; + let __v_79: G = __r_arr[18]; + let __v_80: G = __r_arr[19]; + let __v_81: G = __r_arr[20]; + let __v_82: G = __r_arr[21]; + let __v_83: G = __r_arr[22]; + let __v_84: G = __r_arr[23]; + let __v_85: G = __r_arr[24]; + let __v_86: G = __r_arr[25]; + let __v_87: G = __r_arr[26]; + let __v_88: G = __r_arr[27]; + let __v_89: G = __r_arr[28]; + let __v_90: G = __r_arr[29]; + let __v_91: G = __r_arr[30]; + let __v_92: G = __r_arr[31]; + let __v_93: G = __r_arr[32]; + let __v_94: G = __r_arr[33]; + let __v_95: G = __r_arr[34]; + let __v_96: G = __r_arr[35]; + let __v_97: G = __r_arr[36]; + let __v_98: G = __r_arr[37]; + let __v_99: G = __r_arr[38]; + let __v_100: G = __r_arr[39]; + let __v_101: G = __r_arr[40]; + let __v_102: G = __r_arr[41]; + let __v_103: G = __r_arr[42]; + let __v_104: G = __r_arr[43]; + let __v_105: G = __r_arr[44]; + let __v_106: G = __r_arr[45]; + let __v_107: G = __r_arr[46]; + let __v_108: G = __r_arr[47]; + match __v_61.as_canonical_u64() { + _ => { + match __v_61.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { 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_110: G = __r_arr[0]; + let __v_111: G = G::from_u64(0); + let __v_112: G = (__v_60 + __v_110); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_113: G = __r_arr[0]; + let __v_114: G = { let __values: [G; 3] = [__v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_114]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + 4u64 => { + match __v_10.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_26, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __v_64: G = __r_arr[3]; + let __v_65: G = __r_arr[4]; + let __v_66: G = __r_arr[5]; + let __v_67: G = __r_arr[6]; + let __v_68: G = __r_arr[7]; + let __v_69: G = __r_arr[8]; + let __v_70: G = __r_arr[9]; + let __v_71: G = __r_arr[10]; + let __v_72: G = __r_arr[11]; + let __v_73: G = __r_arr[12]; + let __v_74: G = __r_arr[13]; + let __v_75: G = __r_arr[14]; + let __v_76: G = __r_arr[15]; + let __v_77: G = __r_arr[16]; + let __v_78: G = __r_arr[17]; + let __v_79: G = __r_arr[18]; + let __v_80: G = __r_arr[19]; + let __v_81: G = __r_arr[20]; + let __v_82: G = __r_arr[21]; + let __v_83: G = __r_arr[22]; + let __v_84: G = __r_arr[23]; + let __v_85: G = __r_arr[24]; + let __v_86: G = __r_arr[25]; + let __v_87: G = __r_arr[26]; + let __v_88: G = __r_arr[27]; + let __v_89: G = __r_arr[28]; + let __v_90: G = __r_arr[29]; + let __v_91: G = __r_arr[30]; + let __v_92: G = __r_arr[31]; + let __v_93: G = __r_arr[32]; + let __v_94: G = __r_arr[33]; + let __v_95: G = __r_arr[34]; + let __v_96: G = __r_arr[35]; + let __v_97: G = __r_arr[36]; + let __v_98: G = __r_arr[37]; + let __v_99: G = __r_arr[38]; + let __v_100: G = __r_arr[39]; + let __v_101: G = __r_arr[40]; + let __v_102: G = __r_arr[41]; + let __v_103: G = __r_arr[42]; + let __v_104: G = __r_arr[43]; + let __v_105: G = __r_arr[44]; + let __v_106: G = __r_arr[45]; + let __v_107: G = __r_arr[46]; + let __v_108: G = __r_arr[47]; + match __v_61.as_canonical_u64() { + _ => { + match __v_61.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { 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_110: G = __r_arr[0]; + let __v_111: G = G::from_u64(0); + let __v_112: G = G::from_u64(1); + 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 !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_113: G = __r_arr[0]; + let __v_114: G = (__v_112 + __v_113); + let __v_115: G = (__v_110 + __v_114); + let __v_116: G = (__v_60 + __v_115); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_117: G = __r_arr[0]; + let __v_118: G = { let __values: [G; 3] = [__v_111, __v_116, __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 __ret: [G; OUT_149] = [__v_118]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + 5u64 => { + match __v_10.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __v_64: G = __r_arr[3]; + let __v_65: G = __r_arr[4]; + let __v_66: G = __r_arr[5]; + let __v_67: G = __r_arr[6]; + let __v_68: G = __r_arr[7]; + let __v_69: G = __r_arr[8]; + let __v_70: G = __r_arr[9]; + let __v_71: G = __r_arr[10]; + let __v_72: G = __r_arr[11]; + let __v_73: G = __r_arr[12]; + let __v_74: G = __r_arr[13]; + let __v_75: G = __r_arr[14]; + let __v_76: G = __r_arr[15]; + let __v_77: G = __r_arr[16]; + let __v_78: G = __r_arr[17]; + let __v_79: G = __r_arr[18]; + let __v_80: G = __r_arr[19]; + let __v_81: G = __r_arr[20]; + let __v_82: G = __r_arr[21]; + let __v_83: G = __r_arr[22]; + let __v_84: G = __r_arr[23]; + let __v_85: G = __r_arr[24]; + let __v_86: G = __r_arr[25]; + let __v_87: G = __r_arr[26]; + let __v_88: G = __r_arr[27]; + let __v_89: G = __r_arr[28]; + let __v_90: G = __r_arr[29]; + let __v_91: G = __r_arr[30]; + let __v_92: G = __r_arr[31]; + let __v_93: G = __r_arr[32]; + let __v_94: G = __r_arr[33]; + let __v_95: G = __r_arr[34]; + let __v_96: G = __r_arr[35]; + let __v_97: G = __r_arr[36]; + let __v_98: G = __r_arr[37]; + let __v_99: G = __r_arr[38]; + let __v_100: G = __r_arr[39]; + let __v_101: G = __r_arr[40]; + let __v_102: G = __r_arr[41]; + let __v_103: G = __r_arr[42]; + let __v_104: G = __r_arr[43]; + let __v_105: G = __r_arr[44]; + let __v_106: G = __r_arr[45]; + let __v_107: G = __r_arr[46]; + let __v_108: G = __r_arr[47]; + match __v_61.as_canonical_u64() { + _ => { + match __v_61.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { 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_110: G = __r_arr[0]; + let __v_111: G = G::from_u64(0); + let __v_112: G = (__v_60 + __v_110); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_113: G = __r_arr[0]; + let __v_114: G = { let __values: [G; 3] = [__v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_114]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + 7u64 => { + match __v_10.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_18, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __v_64: G = __r_arr[3]; + let __v_65: G = __r_arr[4]; + let __v_66: G = __r_arr[5]; + let __v_67: G = __r_arr[6]; + let __v_68: G = __r_arr[7]; + let __v_69: G = __r_arr[8]; + let __v_70: G = __r_arr[9]; + let __v_71: G = __r_arr[10]; + let __v_72: G = __r_arr[11]; + let __v_73: G = __r_arr[12]; + let __v_74: G = __r_arr[13]; + let __v_75: G = __r_arr[14]; + let __v_76: G = __r_arr[15]; + let __v_77: G = __r_arr[16]; + let __v_78: G = __r_arr[17]; + let __v_79: G = __r_arr[18]; + let __v_80: G = __r_arr[19]; + let __v_81: G = __r_arr[20]; + let __v_82: G = __r_arr[21]; + let __v_83: G = __r_arr[22]; + let __v_84: G = __r_arr[23]; + let __v_85: G = __r_arr[24]; + let __v_86: G = __r_arr[25]; + let __v_87: G = __r_arr[26]; + let __v_88: G = __r_arr[27]; + let __v_89: G = __r_arr[28]; + let __v_90: G = __r_arr[29]; + let __v_91: G = __r_arr[30]; + let __v_92: G = __r_arr[31]; + let __v_93: G = __r_arr[32]; + let __v_94: G = __r_arr[33]; + let __v_95: G = __r_arr[34]; + let __v_96: G = __r_arr[35]; + let __v_97: G = __r_arr[36]; + let __v_98: G = __r_arr[37]; + let __v_99: G = __r_arr[38]; + let __v_100: G = __r_arr[39]; + let __v_101: G = __r_arr[40]; + let __v_102: G = __r_arr[41]; + let __v_103: G = __r_arr[42]; + let __v_104: G = __r_arr[43]; + let __v_105: G = __r_arr[44]; + let __v_106: G = __r_arr[45]; + let __v_107: G = __r_arr[46]; + let __v_108: G = __r_arr[47]; + match __v_61.as_canonical_u64() { + _ => { + match __v_61.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_62, __v_109]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { 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_110: G = __r_arr[0]; + let __v_111: G = G::from_u64(0); + let __v_112: G = (__v_60 + __v_110); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_113: G = __r_arr[0]; + let __v_114: G = { let __values: [G; 3] = [__v_111, __v_112, __v_113]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_149] = [__v_114]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_61.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + _ => { + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(1); + let __v_62: G = (__v_3 + __v_61); + let __r_arr: [G; OUT_149] = { let __args: [G; IN_149] = [__v_8, __v_59, __v_2, __v_62, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[149].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_149] = unsafe { *(result.output.as_ptr() as *const [G; OUT_149]) }; __ret } else { aiur_fn_149(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __v_64: G = { let __values: [G; 3] = [__v_60, __v_3, __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 __ret: [G; OUT_149] = [__v_64]; + record.function_queries[149].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_57.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_150: usize = 4; +const IN_150: usize = 4; +const OUT_150: usize = 2; +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]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(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 = 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_150] = [__v_9, __v_12]; + record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { 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]; + let __v_8: 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_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_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_5, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_135] = { let __args: [G; IN_135] = [__v_5, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[135].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_135] = unsafe { *(result.output.as_ptr() as *const [G; OUT_135]) }; __ret } else { aiur_fn_135(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 3] = [__v_18, __v_17, __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_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(1); + let __v_22: G = G::from_u64(1); + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_20, __v_23, __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_150] = [__v_19, __v_24]; + record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4294967295u64 => { + let __r_arr: [G; OUT_125] = { let __args: [G; IN_125] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[125].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_125] = unsafe { *(result.output.as_ptr() as *const [G; OUT_125]) }; __ret } else { aiur_fn_125(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = { let __values: [G; 3] = [__v_18, __v_19, __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_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 3] = [__v_21, __v_17, __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_150] = [__v_20, __v_22]; + record.function_queries[150].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(1); + let __v_19: G = (__v_16 - __v_18); + let __v_20: G = { let __values: [G; 3] = [__v_17, __v_19, __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_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 3] = [__v_21, __v_24, __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_150] = [__v_20, __v_25]; + record.function_queries[150].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_151: usize = 1; +const IN_151: usize = 1; +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 __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + let __v_48: G = __loaded[47]; + match __v_1.as_canonical_u64() { + _ => { + match __v_1.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_144] = { let __args: [G; IN_144] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[144].get_mut(&__args[..]) { 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]; + match __v_49.as_canonical_u64() { + 0u64 => { + let __v_50: G = G::from_u64(0); + let __ret: [G; OUT_151] = [__v_50]; + record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __ret: [G; OUT_151] = [__v_0]; + record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64())); + }, + } + }, + _ => { + let __v_49: G = G::from_u64(0); + let __ret: [G; OUT_151] = [__v_49]; + record.function_queries[151].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_152: usize = 4; +const IN_152: usize = 4; +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 __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_152] = [__v_3]; + record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_10: G = (__v_5 - __v_0); + match __v_10.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_152] = [__v_8]; + record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_0, __v_6, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_152] = [__v_11]; + record.function_queries[152].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_153: usize = 4; +const IN_153: usize = 4; +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 __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_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(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_153] = [__v_9]; + record.function_queries[153].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_151] = { let __args: [G; IN_151] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { + 0u64 => { + break '__mc_0 [__v_8]; + }, + _ => { + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_10, __v_2, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + break '__mc_0 [__v_11]; + }, +} + }; + let __v_11: G = __mc_out___mc_0[0]; + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_10.as_canonical_u64() { + 0u64 => { + break '__mc_1 [__v_2]; + }, + _ => { + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_10, __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 } }; + break '__mc_1 [__v_13]; + }, +} + }; + let __v_12: G = __mc_out___mc_1[0]; + let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_10.as_canonical_u64() { + 0u64 => { + break '__mc_2 [__v_3]; + }, + _ => { + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 3] = [__v_13, __v_11, __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 } }; + break '__mc_2 [__v_14]; + }, +} + }; + let __v_13: G = __mc_out___mc_2[0]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_153] = { let __args: [G; IN_153] = [__v_6, __v_9, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { 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 = { let __values: [G; 3] = [__v_14, __v_11, __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_153] = [__v_16]; + record.function_queries[153].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +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_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 = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_153] = { let __args: [G; IN_153] = [__v_0, __v_1, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[153].get_mut(&__args[..]) { 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_8: G = __r_arr[0]; + let __ret: [G; OUT_154] = [__v_8]; + record.function_queries[154].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_155: usize = 10; +const IN_155: usize = 10; +const OUT_155: usize = 6; +fn aiur_fn_155( + inp: [G; IN_155], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_155], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_155] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; + record.function_queries[155].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_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + match __v_13.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_151] = { let __args: [G; IN_151] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[151].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_151] = unsafe { *(result.output.as_ptr() as *const [G; OUT_151]) }; __ret } else { aiur_fn_151(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_12, __v_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[155].get_mut(&__args[..]) { 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_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_155] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_152] = { let __args: [G; IN_152] = [__v_16, __v_2, __v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[152].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_152] = unsafe { *(result.output.as_ptr() as *const [G; OUT_152]) }; __ret } else { aiur_fn_152(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 3] = [__v_18, __v_16, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 3] = [__v_20, __v_17, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_11, __v_17, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __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_155] = { let __args: [G; IN_155] = [__v_12, __v_15, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { 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_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_155] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + record.function_queries[155].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_156: usize = 2; +const IN_156: usize = 2; +const OUT_156: usize = 6; +fn aiur_fn_156( + inp: [G; IN_156], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_156], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __r_arr: [G; OUT_155] = { let __args: [G; IN_155] = [__v_0, __v_1, __v_4, __v_7, __v_8, __v_9, __v_9, __v_9, __v_9, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[155].get_mut(&__args[..]) { 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_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __ret: [G; OUT_156] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; + record.function_queries[156].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +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_157], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 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_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 __ret: [G; OUT_157] = [__v_0]; + record.function_queries[157].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_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]; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_157] = [__v_14]; + record.function_queries[157].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_158: usize = 3; +const IN_158: usize = 3; +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_158], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __ret: [G; OUT_158] = [__v_3]; + record.function_queries[158].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_159: usize = 2; +const IN_159: usize = 2; +const OUT_159: usize = 1; +fn aiur_fn_159( + inp: [G; IN_159], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_159], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + let __v_38: G = __loaded[36]; + let __v_39: G = __loaded[37]; + let __v_40: G = __loaded[38]; + let __v_41: G = __loaded[39]; + let __v_42: G = __loaded[40]; + let __v_43: G = __loaded[41]; + let __v_44: G = __loaded[42]; + let __v_45: G = __loaded[43]; + let __v_46: G = __loaded[44]; + let __v_47: G = __loaded[45]; + let __v_48: G = __loaded[46]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_49: G = G::from_u64(1); + let __v_50: G = G::from_u64(1); + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_159] = [__v_51]; + record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_49: G = G::from_u64(0); + let __r_arr: [G; OUT_131] = { let __args: [G; IN_131] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __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[131].get_mut(&__args[..]) { 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_50: G = __r_arr[0]; + let __v_51: G = (__v_1 + __v_50); + let __r_arr: [G; OUT_159] = { let __args: [G; IN_159] = [__v_48, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[159].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_159] = unsafe { *(result.output.as_ptr() as *const [G; OUT_159]) }; __ret } else { aiur_fn_159(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __v_53: G = { let __values: [G; 3] = [__v_49, __v_1, __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_159] = [__v_53]; + record.function_queries[159].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_160: usize = 3; +const IN_160: usize = 3; +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_160], ExecError> { + stacker::maybe_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 __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_160] = [__v_5]; + record.function_queries[160].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(1); + let __v_5: G = (__v_4 + __v_2); + let __v_6: G = (__v_1 + __v_5); + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_0 - __v_7); + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 + __v_9); + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_8, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { 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 __v_12: G = { let __values: [G; 3] = [__v_3, __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_160] = [__v_12]; + record.function_queries[160].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 = 1; +fn aiur_fn_161( + inp: [G; IN_161], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_161], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __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 !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 __ret: [G; OUT_161] = [__v_3]; + record.function_queries[161].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +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_162], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + let __v_38: G = __loaded[36]; + let __v_39: G = __loaded[37]; + let __v_40: G = __loaded[38]; + let __v_41: G = __loaded[39]; + let __v_42: G = __loaded[40]; + let __v_43: G = __loaded[41]; + let __v_44: G = __loaded[42]; + let __v_45: G = __loaded[43]; + let __v_46: G = __loaded[44]; + let __v_47: G = __loaded[45]; + let __v_48: G = __loaded[46]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_49: G = G::from_u64(1); + let __v_50: G = G::from_u64(1); + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_162] = [__v_51]; + record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_3.as_canonical_u64() { + 1u64 => { + match __v_4.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(0); + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_49, __v_1, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { 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_51: G = __r_arr[0]; + let __v_52: G = G::from_u64(1); + let __v_53: G = (__v_52 + __v_49); + let __v_54: G = (__v_1 + __v_53); + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_48, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { 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_55: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_51, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __ret: [G; OUT_162] = [__v_56]; + record.function_queries[162].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_162] = { let __args: [G; IN_162] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { 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_51: G = __r_arr[0]; + let __ret: [G; OUT_162] = [__v_51]; + record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_49: G = G::from_u64(1); + let __v_50: G = (__v_1 + __v_49); + let __r_arr: [G; OUT_162] = { let __args: [G; IN_162] = [__v_48, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[162].get_mut(&__args[..]) { 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_51: G = __r_arr[0]; + let __ret: [G; OUT_162] = [__v_51]; + record.function_queries[162].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_163: usize = 1; +const IN_163: usize = 1; +const OUT_163: usize = 1; +fn aiur_fn_163( + inp: [G; IN_163], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_163], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(0); + let __ret: [G; OUT_163] = [__v_48]; + record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(1); + let __ret: [G; OUT_163] = [__v_48]; + record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { 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_48: G = __r_arr[0]; + let __ret: [G; OUT_163] = [__v_48]; + record.function_queries[163].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_164: usize = 19; +const IN_164: usize = 19; +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_164], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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() { + 11u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_21: G = __loaded[0]; + let __v_22: G = __loaded[1]; + let __v_23: G = __loaded[2]; + match __v_21.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_24: G = __loaded[0]; + let __v_25: G = __loaded[1]; + let __v_26: G = __loaded[2]; + let __v_27: G = __loaded[3]; + let __v_28: G = __loaded[4]; + let __v_29: G = __loaded[5]; + let __v_30: G = __loaded[6]; + let __v_31: G = __loaded[7]; + let __v_32: G = __loaded[8]; + let __v_33: G = __loaded[9]; + let __v_34: G = __loaded[10]; + let __v_35: G = __loaded[11]; + let __v_36: G = __loaded[12]; + let __v_37: G = __loaded[13]; + let __v_38: G = __loaded[14]; + let __v_39: G = __loaded[15]; + let __v_40: G = __loaded[16]; + let __v_41: G = __loaded[17]; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __v_43: G = __r_arr[1]; + let __v_44: G = __r_arr[2]; + let __v_45: G = __r_arr[3]; + let __v_46: G = __r_arr[4]; + let __v_47: G = __r_arr[5]; + let __v_48: G = __r_arr[6]; + let __v_49: G = __r_arr[7]; + let __v_50: G = __r_arr[8]; + let __v_51: G = __r_arr[9]; + let __v_52: G = __r_arr[10]; + let __v_53: G = __r_arr[11]; + let __v_54: G = __r_arr[12]; + let __v_55: G = __r_arr[13]; + let __v_56: G = __r_arr[14]; + let __v_57: G = __r_arr[15]; + let __v_58: G = __r_arr[16]; + let __v_59: G = __r_arr[17]; + let __ret: [G; OUT_164] = [__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]; + record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + _ => { + let __ret: [G; OUT_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; + record.function_queries[164].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_165: usize = 20; +const IN_165: usize = 20; +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_165], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + match __v_18.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + let __v_26: G = __r_arr[6]; + let __v_27: G = __r_arr[7]; + let __v_28: G = __r_arr[8]; + let __v_29: G = __r_arr[9]; + let __v_30: G = __r_arr[10]; + let __v_31: G = __r_arr[11]; + let __v_32: G = __r_arr[12]; + let __v_33: G = __r_arr[13]; + let __v_34: G = __r_arr[14]; + let __v_35: G = __r_arr[15]; + let __v_36: G = __r_arr[16]; + let __v_37: G = __r_arr[17]; + let __ret: [G; OUT_165] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; + record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_24: G = __r_arr[4]; + let __v_25: G = __r_arr[5]; + let __v_26: G = __r_arr[6]; + let __v_27: G = __r_arr[7]; + let __v_28: G = __r_arr[8]; + let __v_29: G = __r_arr[9]; + let __v_30: G = __r_arr[10]; + let __v_31: G = __r_arr[11]; + let __v_32: G = __r_arr[12]; + let __v_33: G = __r_arr[13]; + let __v_34: G = __r_arr[14]; + let __v_35: G = __r_arr[15]; + let __v_36: G = __r_arr[16]; + let __v_37: G = __r_arr[17]; + match __v_20.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_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_38: G = __loaded[0]; + let __v_39: G = __loaded[1]; + let __v_40: G = __loaded[2]; + let __v_41: G = __loaded[3]; + let __v_42: G = __loaded[4]; + let __v_43: G = __loaded[5]; + let __v_44: G = __loaded[6]; + let __v_45: G = __loaded[7]; + let __v_46: G = __loaded[8]; + let __v_47: G = __loaded[9]; + let __v_48: G = __loaded[10]; + let __v_49: G = __loaded[11]; + let __v_50: G = __loaded[12]; + let __v_51: G = __loaded[13]; + let __v_52: G = __loaded[14]; + let __v_53: G = __loaded[15]; + let __v_54: G = __loaded[16]; + let __v_55: G = __loaded[17]; + let __v_56: G = G::from_u64(1); + let __v_57: G = (__v_18 - __v_56); + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_57, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { 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_58: G = __r_arr[0]; + let __v_59: G = __r_arr[1]; + let __v_60: G = __r_arr[2]; + let __v_61: G = __r_arr[3]; + let __v_62: G = __r_arr[4]; + let __v_63: G = __r_arr[5]; + let __v_64: G = __r_arr[6]; + let __v_65: G = __r_arr[7]; + let __v_66: G = __r_arr[8]; + let __v_67: G = __r_arr[9]; + let __v_68: G = __r_arr[10]; + let __v_69: G = __r_arr[11]; + let __v_70: G = __r_arr[12]; + let __v_71: G = __r_arr[13]; + let __v_72: G = __r_arr[14]; + let __v_73: G = __r_arr[15]; + let __v_74: G = __r_arr[16]; + let __v_75: G = __r_arr[17]; + let __ret: [G; OUT_165] = [__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]; + record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_165] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17]; + record.function_queries[165].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_166: usize = 19; +const IN_166: usize = 19; +const OUT_166: usize = 18; +fn aiur_fn_166( + inp: [G; IN_166], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_166], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = __r_arr[8]; + let __v_28: G = __r_arr[9]; + let __v_29: G = __r_arr[10]; + let __v_30: G = __r_arr[11]; + let __v_31: G = __r_arr[12]; + let __v_32: G = __r_arr[13]; + let __v_33: G = __r_arr[14]; + let __v_34: G = __r_arr[15]; + let __v_35: G = __r_arr[16]; + let __v_36: G = __r_arr[17]; + match __v_19.as_canonical_u64() { + 7u64 => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_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: 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 __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__v_37, __v_38, __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[166].get_mut(&__args[..]) { 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_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + let __v_57: G = __r_arr[2]; + let __v_58: G = __r_arr[3]; + let __v_59: G = __r_arr[4]; + let __v_60: G = __r_arr[5]; + let __v_61: G = __r_arr[6]; + let __v_62: G = __r_arr[7]; + let __v_63: G = __r_arr[8]; + let __v_64: G = __r_arr[9]; + let __v_65: G = __r_arr[10]; + let __v_66: G = __r_arr[11]; + let __v_67: G = __r_arr[12]; + let __v_68: G = __r_arr[13]; + let __v_69: G = __r_arr[14]; + let __v_70: G = __r_arr[15]; + let __v_71: G = __r_arr[16]; + let __v_72: G = __r_arr[17]; + let __ret: [G; OUT_166] = [__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]; + record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_164] = { let __args: [G; IN_164] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __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[164].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_164] = unsafe { *(result.output.as_ptr() as *const [G; OUT_164]) }; __ret } else { aiur_fn_164(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __v_40: G = __r_arr[3]; + let __v_41: G = __r_arr[4]; + let __v_42: G = __r_arr[5]; + let __v_43: G = __r_arr[6]; + let __v_44: G = __r_arr[7]; + let __v_45: G = __r_arr[8]; + let __v_46: G = __r_arr[9]; + let __v_47: G = __r_arr[10]; + let __v_48: G = __r_arr[11]; + let __v_49: G = __r_arr[12]; + let __v_50: G = __r_arr[13]; + let __v_51: G = __r_arr[14]; + let __v_52: G = __r_arr[15]; + let __v_53: G = __r_arr[16]; + let __v_54: G = __r_arr[17]; + let __ret: [G; OUT_166] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; + record.function_queries[166].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_167: usize = 21; +const IN_167: usize = 21; +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_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 __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __r_arr: [G; OUT_165] = { let __args: [G; IN_165] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[165].get_mut(&__args[..]) { 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_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 __v_27: G = __r_arr[6]; + let __v_28: G = __r_arr[7]; + let __v_29: G = __r_arr[8]; + let __v_30: G = __r_arr[9]; + let __v_31: G = __r_arr[10]; + let __v_32: G = __r_arr[11]; + let __v_33: G = __r_arr[12]; + let __v_34: G = __r_arr[13]; + let __v_35: G = __r_arr[14]; + let __v_36: G = __r_arr[15]; + let __v_37: G = __r_arr[16]; + let __v_38: G = __r_arr[17]; + match __v_21.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_22.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 18 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 18] = __args[..18].try_into().unwrap(); __arr }; + let __v_39: G = __loaded[0]; + let __v_40: G = __loaded[1]; + let __v_41: G = __loaded[2]; + let __v_42: G = __loaded[3]; + let __v_43: G = __loaded[4]; + let __v_44: G = __loaded[5]; + let __v_45: G = __loaded[6]; + let __v_46: G = __loaded[7]; + let __v_47: G = __loaded[8]; + let __v_48: G = __loaded[9]; + let __v_49: G = __loaded[10]; + let __v_50: G = __loaded[11]; + let __v_51: G = __loaded[12]; + let __v_52: G = __loaded[13]; + let __v_53: G = __loaded[14]; + let __v_54: G = __loaded[15]; + let __v_55: G = __loaded[16]; + let __v_56: G = __loaded[17]; + let __r_arr: [G; OUT_166] = { let __args: [G; IN_166] = [__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_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[166].get_mut(&__args[..]) { 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_57: G = __r_arr[0]; + let __v_58: G = __r_arr[1]; + let __v_59: G = __r_arr[2]; + let __v_60: G = __r_arr[3]; + let __v_61: G = __r_arr[4]; + let __v_62: G = __r_arr[5]; + let __v_63: G = __r_arr[6]; + let __v_64: G = __r_arr[7]; + let __v_65: G = __r_arr[8]; + let __v_66: G = __r_arr[9]; + let __v_67: G = __r_arr[10]; + let __v_68: G = __r_arr[11]; + let __v_69: G = __r_arr[12]; + let __v_70: G = __r_arr[13]; + let __v_71: G = __r_arr[14]; + let __v_72: G = __r_arr[15]; + let __v_73: G = __r_arr[16]; + let __v_74: G = __r_arr[17]; + match __v_57.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __ret: [G; OUT_167] = [__v_76]; + record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_75: G = G::from_u64(0); + let __v_76: G = G::from_u64(0); + let __v_77: G = G::from_u64(0); + let __v_78: G = G::from_u64(0); + let __v_79: G = G::from_u64(0); + let __v_80: G = G::from_u64(0); + let __v_81: G = G::from_u64(0); + let __v_82: G = G::from_u64(0); + let __v_83: G = G::from_u64(0); + let __v_84: G = G::from_u64(0); + let __v_85: G = G::from_u64(0); + let __v_86: G = G::from_u64(0); + let __v_87: G = G::from_u64(0); + let __v_88: G = G::from_u64(0); + let __v_89: G = G::from_u64(0); + 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 __v_93: G = G::from_u64(0); + let __v_94: G = G::from_u64(0); + let __v_95: G = G::from_u64(0); + let __v_96: G = G::from_u64(0); + let __v_97: G = G::from_u64(0); + let __v_98: G = G::from_u64(0); + let __v_99: G = G::from_u64(0); + let __v_100: G = G::from_u64(0); + let __v_101: G = G::from_u64(0); + let __v_102: G = G::from_u64(0); + let __v_103: G = G::from_u64(0); + let __v_104: G = G::from_u64(0); + let __v_105: G = G::from_u64(0); + let __v_106: G = G::from_u64(0); + let __v_107: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_107]; + record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_71]; + record.function_queries[167].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_168: usize = 48; +const IN_168: usize = 48; +const OUT_168: usize = 2; +fn aiur_fn_168( + inp: [G; IN_168], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_168], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + match __v_0.as_canonical_u64() { + _ => { + let __loaded: [G; 18] = { let __mq = record.memory_queries.get_mut(&18).ok_or(ExecError::InvalidMemorySize(18))?; let __ptr_u64 = __v_42.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_48: G = __loaded[0]; + let __v_49: G = __loaded[1]; + let __v_50: G = __loaded[2]; + let __v_51: G = __loaded[3]; + let __v_52: G = __loaded[4]; + let __v_53: G = __loaded[5]; + let __v_54: G = __loaded[6]; + let __v_55: G = __loaded[7]; + let __v_56: G = __loaded[8]; + let __v_57: G = __loaded[9]; + let __v_58: G = __loaded[10]; + let __v_59: G = __loaded[11]; + let __v_60: G = __loaded[12]; + let __v_61: G = __loaded[13]; + let __v_62: G = __loaded[14]; + let __v_63: G = __loaded[15]; + let __v_64: G = __loaded[16]; + let __v_65: G = __loaded[17]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __v_68: G = (__v_66 + __v_67); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__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[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __v_70: G = (__v_68 + __v_69); + 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 !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_71: G = __r_arr[0]; + let __v_72: G = (__v_70 + __v_71); + let __r_arr: [G; OUT_167] = { let __args: [G; IN_167] = [__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_72, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[167].get_mut(&__args[..]) { 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_73: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __v_75: G = __r_arr[1]; + let __v_76: G = __r_arr[2]; + let __v_77: G = __r_arr[3]; + let __v_78: G = __r_arr[4]; + let __v_79: G = __r_arr[5]; + let __v_80: G = __r_arr[6]; + let __v_81: G = __r_arr[7]; + let __v_82: G = __r_arr[8]; + let __v_83: G = __r_arr[9]; + let __v_84: G = __r_arr[10]; + let __v_85: G = __r_arr[11]; + let __v_86: G = __r_arr[12]; + let __v_87: G = __r_arr[13]; + let __v_88: G = __r_arr[14]; + let __v_89: G = __r_arr[15]; + let __v_90: G = __r_arr[16]; + let __v_91: G = __r_arr[17]; + let __v_92: G = __r_arr[18]; + let __v_93: G = __r_arr[19]; + let __v_94: G = __r_arr[20]; + let __v_95: G = __r_arr[21]; + let __v_96: G = __r_arr[22]; + let __v_97: G = __r_arr[23]; + let __v_98: G = __r_arr[24]; + let __v_99: G = __r_arr[25]; + let __v_100: G = __r_arr[26]; + let __v_101: G = __r_arr[27]; + let __v_102: G = __r_arr[28]; + let __v_103: G = __r_arr[29]; + let __v_104: G = __r_arr[30]; + let __v_105: G = __r_arr[31]; + let __v_106: G = __r_arr[32]; + let __v_107: G = __r_arr[33]; + let __v_108: G = __r_arr[34]; + let __v_109: G = __r_arr[35]; + let __v_110: G = __r_arr[36]; + let __v_111: G = __r_arr[37]; + let __v_112: G = __r_arr[38]; + let __v_113: G = __r_arr[39]; + let __v_114: G = __r_arr[40]; + let __v_115: G = __r_arr[41]; + let __v_116: G = __r_arr[42]; + let __v_117: G = __r_arr[43]; + let __v_118: G = __r_arr[44]; + let __v_119: G = __r_arr[45]; + let __v_120: G = __r_arr[46]; + let __v_121: G = __r_arr[47]; + match __v_74.as_canonical_u64() { + _ => { + match __v_74.as_canonical_u64() { + 6u64 => { + match __v_75.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_122: G = __r_arr[0]; + let __v_123: G = __r_arr[1]; + let __v_124: G = __r_arr[2]; + let __v_125: G = __r_arr[3]; + let __v_126: G = __r_arr[4]; + let __v_127: G = __r_arr[5]; + let __v_128: G = __r_arr[6]; + let __v_129: G = __r_arr[7]; + let __v_130: G = __r_arr[8]; + let __v_131: G = __r_arr[9]; + let __v_132: G = __r_arr[10]; + let __v_133: G = __r_arr[11]; + let __v_134: G = __r_arr[12]; + let __v_135: G = __r_arr[13]; + let __v_136: G = __r_arr[14]; + let __v_137: G = __r_arr[15]; + let __v_138: G = __r_arr[16]; + let __v_139: G = __r_arr[17]; + let __v_140: G = __r_arr[18]; + let __v_141: G = __r_arr[19]; + let __v_142: G = __r_arr[20]; + let __v_143: G = __r_arr[21]; + let __v_144: G = __r_arr[22]; + let __v_145: G = __r_arr[23]; + let __v_146: G = __r_arr[24]; + let __v_147: G = __r_arr[25]; + let __v_148: G = __r_arr[26]; + let __v_149: G = __r_arr[27]; + let __v_150: G = __r_arr[28]; + let __v_151: G = __r_arr[29]; + let __v_152: G = __r_arr[30]; + let __v_153: G = __r_arr[31]; + let __v_154: G = __r_arr[32]; + let __v_155: G = __r_arr[33]; + let __v_156: G = __r_arr[34]; + let __v_157: G = __r_arr[35]; + let __v_158: G = __r_arr[36]; + let __v_159: G = __r_arr[37]; + let __v_160: G = __r_arr[38]; + let __v_161: G = __r_arr[39]; + let __v_162: G = __r_arr[40]; + let __v_163: G = __r_arr[41]; + let __v_164: G = __r_arr[42]; + let __v_165: G = __r_arr[43]; + let __v_166: G = __r_arr[44]; + let __v_167: G = __r_arr[45]; + let __v_168: G = __r_arr[46]; + let __v_169: G = __r_arr[47]; + match __v_122.as_canonical_u64() { + _ => { + match __v_122.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_83, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __v_170: G = __r_arr[0]; + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_171: G = __r_arr[0]; + let __r_arr: [G; OUT_169] = { let __args: [G; IN_169] = [__v_123, __v_170, __v_171]; let __cu = unconstrained; if let Some(result) = record.function_queries[169].get_mut(&__args[..]) { 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_172: G = __r_arr[0]; + let __ret: [G; OUT_168] = [__v_172, __v_83]; + record.function_queries[168].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_122.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_74.as_canonical_u64())); + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_169: usize = 3; +const IN_169: usize = 3; +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_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 = inp[2]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_169] = [__v_4]; + record.function_queries[169].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_170: usize = 4; +const IN_170: usize = 4; +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_170], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 47] = { let __mq = record.memory_queries.get_mut(&47).ok_or(ExecError::InvalidMemorySize(47))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).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 }; + 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]; + let __v_10: G = __loaded[6]; + let __v_11: G = __loaded[7]; + let __v_12: G = __loaded[8]; + let __v_13: G = __loaded[9]; + let __v_14: G = __loaded[10]; + let __v_15: G = __loaded[11]; + let __v_16: G = __loaded[12]; + let __v_17: G = __loaded[13]; + let __v_18: G = __loaded[14]; + let __v_19: G = __loaded[15]; + let __v_20: G = __loaded[16]; + let __v_21: G = __loaded[17]; + let __v_22: G = __loaded[18]; + let __v_23: G = __loaded[19]; + let __v_24: G = __loaded[20]; + let __v_25: G = __loaded[21]; + let __v_26: G = __loaded[22]; + let __v_27: G = __loaded[23]; + let __v_28: G = __loaded[24]; + let __v_29: G = __loaded[25]; + let __v_30: G = __loaded[26]; + let __v_31: G = __loaded[27]; + let __v_32: G = __loaded[28]; + let __v_33: G = __loaded[29]; + let __v_34: G = __loaded[30]; + let __v_35: G = __loaded[31]; + let __v_36: G = __loaded[32]; + let __v_37: G = __loaded[33]; + let __v_38: G = __loaded[34]; + let __v_39: G = __loaded[35]; + let __v_40: G = __loaded[36]; + let __v_41: G = __loaded[37]; + let __v_42: G = __loaded[38]; + let __v_43: G = __loaded[39]; + let __v_44: G = __loaded[40]; + let __v_45: G = __loaded[41]; + let __v_46: G = __loaded[42]; + let __v_47: G = __loaded[43]; + let __v_48: G = __loaded[44]; + let __v_49: G = __loaded[45]; + let __v_50: G = __loaded[46]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_51: G = G::from_u64(1); + let __v_52: G = G::from_u64(1); + let __v_53: G = { let __values: [G; 3] = [__v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_170] = [__v_53]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + 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_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[131].get_mut(&__args[..]) { 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_51: G = __r_arr[0]; + let __v_52: G = (__v_3 - __v_2); + let __v_53: G = G::from_bool((__v_52 == G::ZERO)); + match __v_53.as_canonical_u64() { + 1u64 => { + match __v_5.as_canonical_u64() { + 1u64 => { + match __v_6.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __v_55: G = G::from_u64(0); + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_54, __v_1, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { 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_56: G = __r_arr[0]; + let __ret: [G; OUT_170] = [__v_56]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_54: G = G::from_u64(1); + let __v_55: G = G::from_u64(1); + let __v_56: G = { let __values: [G; 3] = [__v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_170] = [__v_56]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __v_54: G = (__v_1 + __v_51); + let __v_55: G = G::from_u64(1); + let __v_56: G = (__v_3 + __v_55); + let __r_arr: [G; OUT_170] = { let __args: [G; IN_170] = [__v_50, __v_54, __v_2, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[170].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_170] = unsafe { *(result.output.as_ptr() as *const [G; OUT_170]) }; __ret } else { aiur_fn_170(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __ret: [G; OUT_170] = [__v_57]; + record.function_queries[170].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_53.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_171: usize = 57; +const IN_171: usize = 57; +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_171], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + let __v_51: G = inp[51]; + let __v_52: G = inp[52]; + let __v_53: G = inp[53]; + let __v_54: G = inp[54]; + let __v_55: G = inp[55]; + let __v_56: G = inp[56]; + match __v_0.as_canonical_u64() { + 1u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_50, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { 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_58: G = __r_arr[0]; + let __v_59: G = (__v_51 + __v_58); + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_160] = { let __args: [G; IN_160] = [__v_57, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[160].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __v_62: G = G::from_u64(4); + let __v_63: G = G::from_u64(0); + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_37, __v_45, __v_46, __v_47, __v_48, __v_49, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = G::from_u64(0); + let __v_66: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_62, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_61, __v_56, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_171] = [__v_67]; + record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __r_arr: [G; OUT_163] = { let __args: [G; IN_163] = [__v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[163].get_mut(&__args[..]) { 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_57: G = __r_arr[0]; + match __v_57.as_canonical_u64() { + 1u64 => { + let __v_58: G = G::from_u64(0); + let __r_arr: [G; OUT_161] = { let __args: [G; IN_161] = [__v_50, __v_51, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[161].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_161] = unsafe { *(result.output.as_ptr() as *const [G; OUT_161]) }; __ret } else { aiur_fn_161(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = G::from_u64(3); + let __v_61: G = G::from_u64(0); + let __v_62: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_60, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_59, __v_56]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = G::from_u64(1); + let __v_64: G = G::from_u64(1); + let __v_65: G = { let __values: [G; 3] = [__v_63, __v_64, __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 = { let __values: [G; 3] = [__v_61, __v_62, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_171] = [__v_66]; + record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_45.as_canonical_u64() { + _ => { + break '__mc_0 [__v_45]; + }, +} + }; + let __v_58: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_53, __v_58, __v_54, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { 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_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __v_61: G = G::from_u64(3); + let __v_62: G = G::from_u64(0); + let __v_63: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_61, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_59, __v_56]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = G::from_u64(1); + let __v_65: G = G::from_u64(1); + let __v_66: G = { let __values: [G; 3] = [__v_64, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = { let __values: [G; 3] = [__v_62, __v_63, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_171] = [__v_67]; + record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_57.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(1); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = { let __values: [G; 52] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_57, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_58, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59, __v_59]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_62: G = G::from_u64(1); + let __v_63: G = G::from_u64(1); + let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_60, __v_61, __v_64]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_171] = [__v_65]; + record.function_queries[171].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_172: usize = 7; +const IN_172: usize = 7; +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_172], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 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 }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + let __v_18: G = __loaded[11]; + let __v_19: G = __loaded[12]; + let __v_20: G = __loaded[13]; + let __v_21: G = __loaded[14]; + let __v_22: G = __loaded[15]; + let __v_23: G = __loaded[16]; + let __v_24: G = __loaded[17]; + let __v_25: G = __loaded[18]; + let __v_26: G = __loaded[19]; + let __v_27: G = __loaded[20]; + let __v_28: G = __loaded[21]; + let __v_29: G = __loaded[22]; + let __v_30: G = __loaded[23]; + let __v_31: G = __loaded[24]; + let __v_32: G = __loaded[25]; + let __v_33: G = __loaded[26]; + let __v_34: G = __loaded[27]; + let __v_35: G = __loaded[28]; + let __v_36: G = __loaded[29]; + let __v_37: G = __loaded[30]; + let __v_38: G = __loaded[31]; + let __v_39: G = __loaded[32]; + let __v_40: G = __loaded[33]; + let __v_41: G = __loaded[34]; + let __v_42: G = __loaded[35]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_43: G = G::from_u64(1); + let __v_44: G = G::from_u64(1); + let __v_45: G = { let __values: [G; 3] = [__v_43, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_172] = [__v_45]; + record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_43: G = G::from_u64(5); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 52] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_43, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_6, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_172] = { let __args: [G; IN_172] = [__v_42, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[172].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_172] = unsafe { *(result.output.as_ptr() as *const [G; OUT_172]) }; __ret } else { aiur_fn_172(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = { let __values: [G; 3] = [__v_45, __v_46, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_172] = [__v_48]; + record.function_queries[172].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_173: usize = 13; +const IN_173: usize = 13; +const OUT_173: usize = 1; +fn aiur_fn_173( + inp: [G; IN_173], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_173], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __loaded: [G; 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 }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + let __v_24: G = __loaded[11]; + let __v_25: G = __loaded[12]; + let __v_26: G = __loaded[13]; + let __v_27: G = __loaded[14]; + let __v_28: G = __loaded[15]; + let __v_29: G = __loaded[16]; + let __v_30: G = __loaded[17]; + let __v_31: G = __loaded[18]; + let __v_32: G = __loaded[19]; + let __v_33: G = __loaded[20]; + let __v_34: G = __loaded[21]; + let __v_35: G = __loaded[22]; + let __v_36: G = __loaded[23]; + let __v_37: G = __loaded[24]; + let __v_38: G = __loaded[25]; + let __v_39: G = __loaded[26]; + let __v_40: G = __loaded[27]; + let __v_41: G = __loaded[28]; + let __v_42: G = __loaded[29]; + let __v_43: G = __loaded[30]; + let __v_44: G = __loaded[31]; + let __v_45: G = __loaded[32]; + let __v_46: G = __loaded[33]; + let __v_47: G = __loaded[34]; + let __v_48: G = __loaded[35]; + let __v_49: G = __loaded[36]; + let __v_50: G = __loaded[37]; + let __v_51: G = __loaded[38]; + let __v_52: G = __loaded[39]; + let __v_53: G = __loaded[40]; + let __v_54: G = __loaded[41]; + let __v_55: G = __loaded[42]; + let __v_56: G = __loaded[43]; + let __v_57: G = __loaded[44]; + let __v_58: G = __loaded[45]; + let __v_59: G = __loaded[46]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_60: G = G::from_u64(1); + let __v_61: G = G::from_u64(1); + let __v_62: G = { let __values: [G; 3] = [__v_60, __v_61, __v_61]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_173] = [__v_62]; + record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_171] = { let __args: [G; IN_171] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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_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[171].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_171] = unsafe { *(result.output.as_ptr() as *const [G; OUT_171]) }; __ret } else { aiur_fn_171(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __v_61: G = G::from_u64(1); + let __v_62: G = (__v_8 + __v_61); + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_59, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_62, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { 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_63: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_60, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __ret: [G; OUT_173] = [__v_64]; + record.function_queries[173].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_174: usize = 1; +const IN_174: usize = 1; +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_174], 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 __ret: [G; OUT_174] = [__v_2, __v_3]; + record.function_queries[174].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_175: usize = 7; +const IN_175: usize = 7; +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 = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_136] = { let __args: [G; IN_136] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[136].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_136] = unsafe { *(result.output.as_ptr() as *const [G; OUT_136]) }; __ret } else { aiur_fn_136(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __v_9: G = __r_arr[2]; + let __v_10: G = __r_arr[3]; + let __v_11: G = __r_arr[4]; + let __v_12: G = __r_arr[5]; + let __r_arr: [G; OUT_137] = { let __args: [G; IN_137] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[137].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_137] = unsafe { *(result.output.as_ptr() as *const [G; OUT_137]) }; __ret } else { aiur_fn_137(__args, record, io_buffer, __cu)? } }; + let __v_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 = { let __values: [G; 6] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_176] = { let __args: [G; IN_176] = [__v_0, __v_1, __v_2, __v_19, __v_3, __v_4, __v_5, __v_6, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_175] = [__v_23]; + record.function_queries[175].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_176: usize = 9; +const IN_176: usize = 9; +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 = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 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_176] = [__v_14]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; 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: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].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]; + let __v_30: G = __loaded[18]; + let __v_31: G = __loaded[19]; + let __v_32: G = __loaded[20]; + let __v_33: G = __loaded[21]; + let __v_34: G = __loaded[22]; + let __v_35: G = __loaded[23]; + let __v_36: G = __loaded[24]; + let __v_37: G = __loaded[25]; + let __v_38: G = __loaded[26]; + let __v_39: G = __loaded[27]; + let __v_40: G = __loaded[28]; + let __v_41: G = __loaded[29]; + let __v_42: G = __loaded[30]; + let __v_43: G = __loaded[31]; + let __v_44: G = __loaded[32]; + let __v_45: G = __loaded[33]; + let __v_46: G = __loaded[34]; + let __v_47: G = __loaded[35]; + let __v_48: G = __loaded[36]; + let __v_49: G = __loaded[37]; + let __v_50: G = __loaded[38]; + let __v_51: G = __loaded[39]; + let __v_52: G = __loaded[40]; + let __v_53: G = __loaded[41]; + let __v_54: G = __loaded[42]; + let __v_55: G = __loaded[43]; + let __v_56: G = __loaded[44]; + let __v_57: G = __loaded[45]; + let __v_58: G = __loaded[46]; + let __v_59: G = __loaded[47]; + 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 !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_60: G = __r_arr[0]; + let __v_61: G = __r_arr[1]; + match __v_12.as_canonical_u64() { + _ => { + match __v_12.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_143] = { let __args: [G; IN_143] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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]; let __cu = unconstrained; if let Some(result) = record.function_queries[143].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_62.as_canonical_u64() { + 0u64 => { + let __v_63: G = G::from_u64(0); + break '__mc_0 [__v_63]; + }, + _ => { + let __r_arr: [G; OUT_142] = { let __args: [G; IN_142] = [__v_62, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[142].get_mut(&__args[..]) { 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_63: G = __r_arr[0]; + break '__mc_0 [__v_63]; + }, +} + }; + let __v_63: G = __mc_out___mc_0[0]; + match __v_63.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __ret: [G; OUT_176] = [__v_64]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_62.as_canonical_u64() { + 0u64 => { + break '__mc_1 [__v_8]; + }, + _ => { + let __v_64: G = G::from_u64(0); + let __v_65: G = { let __values: [G; 3] = [__v_64, __v_62, __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 } }; + break '__mc_1 [__v_65]; + }, +} + }; + let __v_64: G = __mc_out___mc_1[0]; + let __r_arr: [G; OUT_132] = { let __args: [G; IN_132] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[132].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_132] = unsafe { *(result.output.as_ptr() as *const [G; OUT_132]) }; __ret } else { aiur_fn_132(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __r_arr: [G; OUT_134] = { let __args: [G; IN_134] = [__v_60, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[134].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_134] = unsafe { *(result.output.as_ptr() as *const [G; OUT_134]) }; __ret } else { aiur_fn_134(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __r_arr: [G; OUT_157] = { let __args: [G; IN_157] = [__v_60, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[157].get_mut(&__args[..]) { 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_67: G = __r_arr[0]; + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { 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_68: G = __r_arr[0]; + let __v_69: G = __r_arr[1]; + let __v_70: G = G::from_u64(0); + let __r_arr: [G; OUT_158] = { let __args: [G; IN_158] = [__v_13, __v_66, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[158].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_158] = unsafe { *(result.output.as_ptr() as *const [G; OUT_158]) }; __ret } else { aiur_fn_158(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __v_72: G = G::from_u64(0); + let __r_arr: [G; OUT_173] = { let __args: [G; IN_173] = [__v_13, __v_57, __v_68, __v_71, __v_69, __v_59, __v_13, __v_66, __v_72, __v_58, __v_2, __v_6, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[173].get_mut(&__args[..]) { 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_73: G = __r_arr[0]; + let __v_74: G = (__v_7 + __v_65); + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_74, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __ret: [G; OUT_176] = [__v_76]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_63.as_canonical_u64())); + }, + } + }, + 6u64 => { + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_176] = [__v_62]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_176] = [__v_62]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_176] = [__v_62]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_176] = [__v_62]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(1); + let __v_66: G = G::from_u64(1); + let __v_67: G = { let __values: [G; 3] = [__v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_68: G = { let __values: [G; 3] = [__v_64, __v_7, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_128] = { let __args: [G; IN_128] = [__v_60]; let __cu = true; if let Some(result) = record.function_queries[128].get_mut(&__args[..]) { 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_69: G = __r_arr[0]; + let __v_70: G = G::from_u64(0); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __v_73: G = { let __values: [G; 52] = [__v_57, __v_62, __v_68, __v_63, __v_59, __v_70, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_69, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71, __v_71]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = G::from_u64(1); + let __v_75: G = (__v_7 + __v_74); + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_75, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __v_77: G = { let __values: [G; 3] = [__v_72, __v_73, __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 __ret: [G; OUT_176] = [__v_77]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __v_64: G = G::from_u64(1); + let __v_65: G = G::from_u64(1); + let __v_66: G = { let __values: [G; 3] = [__v_64, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = G::from_u64(1); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = { let __values: [G; 52] = [__v_57, __v_62, __v_66, __v_63, __v_59, __v_67, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __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_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]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = G::from_u64(1); + let __v_72: G = (__v_7 + __v_71); + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_72, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + 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 __ret: [G; OUT_176] = [__v_74]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __v_64: G = G::from_u64(1); + let __v_65: G = G::from_u64(1); + let __v_66: G = { let __values: [G; 3] = [__v_64, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = G::from_u64(2); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = { let __values: [G; 52] = [__v_57, __v_62, __v_66, __v_63, __v_59, __v_67, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __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_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]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = G::from_u64(1); + let __v_72: G = (__v_7 + __v_71); + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_72, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + 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 __ret: [G; OUT_176] = [__v_74]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_150] = { let __args: [G; IN_150] = [__v_58, __v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[150].get_mut(&__args[..]) { 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_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __r_arr: [G; OUT_168] = { let __args: [G; IN_168] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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_58, __v_57, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[168].get_mut(&__args[..]) { 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_64: G = __r_arr[0]; + let __v_65: G = __r_arr[1]; + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(1); + let __v_68: G = G::from_u64(1); + let __v_69: G = { let __values: [G; 3] = [__v_67, __v_68, __v_68]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_70: G = { let __values: [G; 3] = [__v_66, __v_7, __v_69]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_71: G = G::from_u64(3); + let __v_72: G = G::from_u64(0); + let __v_73: G = { let __values: [G; 52] = [__v_57, __v_62, __v_70, __v_63, __v_59, __v_71, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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_64, __v_65]; let __mq = record.memory_queries.get_mut(&52).ok_or(ExecError::InvalidMemorySize(52))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_74: G = G::from_u64(1); + let __v_75: G = (__v_7 + __v_74); + let __r_arr: [G; OUT_176] = { let __args: [G; IN_176] = [__v_11, __v_61, __v_2, __v_3, __v_4, __v_5, __v_6, __v_75, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[176].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_176] = unsafe { *(result.output.as_ptr() as *const [G; OUT_176]) }; __ret } else { aiur_fn_176(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __v_77: G = { let __values: [G; 3] = [__v_72, __v_73, __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 __ret: [G; OUT_176] = [__v_77]; + record.function_queries[176].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_177: usize = 10; +const IN_177: usize = 10; +const OUT_177: usize = 2; +fn aiur_fn_177( + inp: [G; IN_177], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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 __v_3: G = inp[3]; + 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 = G::from_u64(0); + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.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_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_177] = [__v_2, __v_3]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_13, __v_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[177].get_mut(&__args[..]) { 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_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __ret: [G; OUT_177] = [__v_15, __v_16]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + let __v_12: G = G::from_u64(4); + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + let __v_24: G = __loaded[11]; + let __v_25: G = __loaded[12]; + let __v_26: G = __loaded[13]; + let __v_27: G = __loaded[14]; + let __v_28: G = __loaded[15]; + let __v_29: G = __loaded[16]; + let __v_30: G = __loaded[17]; + let __v_31: G = __loaded[18]; + let __v_32: G = __loaded[19]; + let __v_33: G = __loaded[20]; + let __v_34: G = __loaded[21]; + let __v_35: G = __loaded[22]; + let __v_36: G = __loaded[23]; + let __v_37: G = __loaded[24]; + let __v_38: G = __loaded[25]; + let __v_39: G = __loaded[26]; + let __v_40: G = __loaded[27]; + let __v_41: G = __loaded[28]; + let __v_42: G = __loaded[29]; + let __v_43: G = __loaded[30]; + let __v_44: G = __loaded[31]; + let __io_pair: (G, G) = { let __key: [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 __info = io_buffer.get_info(__v_12, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_45: G = __io_pair.0; + let __v_46: G = __io_pair.1; + let __v_47: G = G::from_u64(4); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_47, __v_45, __v_46]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_48: 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_48.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_49: G = __loaded[0]; + let __v_50: G = __loaded[1]; + let __v_51: G = __loaded[2]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_49.as_canonical_u64() { + 0u64 => { + break '__mc_0 [__v_50]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_49.as_canonical_u64())); + }, +} + }; + let __v_52: G = __mc_out___mc_0[0]; + match __v_52.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_53: G = __loaded[0]; + let __v_54: G = __loaded[1]; + let __v_55: G = __loaded[2]; + match __v_53.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_177] = [__v_2, __v_3]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_54, __v_55, __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[177].get_mut(&__args[..]) { 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_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __ret: [G; OUT_177] = [__v_56, __v_57]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_53.as_canonical_u64())); + }, + } + }, + _ => { + let __v_53: G = G::from_u64(0); + let __v_54: G = { let __values: [G; 3] = [__v_53, __v_0, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_55: G = G::from_u64(1); + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_0, __v_55, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __v_58: G = __r_arr[2]; + let __v_59: G = __r_arr[3]; + let __v_60: G = __r_arr[4]; + let __v_61: G = __r_arr[5]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __v_63: G = __r_arr[1]; + let __v_64: G = __r_arr[2]; + let __v_65: G = __r_arr[3]; + let __v_66: G = __r_arr[4]; + let __v_67: G = __r_arr[5]; + let __v_68: G = __r_arr[6]; + let __v_69: G = __r_arr[7]; + let __v_70: G = __r_arr[8]; + let __v_71: G = __r_arr[9]; + let __v_72: G = __r_arr[10]; + let __v_73: G = __r_arr[11]; + let __v_74: G = __r_arr[12]; + let __v_75: G = __r_arr[13]; + let __v_76: G = __r_arr[14]; + let __v_77: G = __r_arr[15]; + let __v_78: G = __r_arr[16]; + let __v_79: G = __r_arr[17]; + let __v_80: G = __r_arr[18]; + let __v_81: G = __r_arr[19]; + let __v_82: G = __r_arr[20]; + let __v_83: G = __r_arr[21]; + let __v_84: G = __r_arr[22]; + let __v_85: G = __r_arr[23]; + let __v_86: G = __r_arr[24]; + let __v_87: G = __r_arr[25]; + let __v_88: G = __r_arr[26]; + let __v_89: G = __r_arr[27]; + let __v_90: G = __r_arr[28]; + let __v_91: G = __r_arr[29]; + let __v_92: G = __r_arr[30]; + let __v_93: G = __r_arr[31]; + let __v_94: G = __r_arr[32]; + let __v_95: G = __r_arr[33]; + let __v_96: G = __r_arr[34]; + let __v_97: G = __r_arr[35]; + let __v_98: G = __r_arr[36]; + let __v_99: G = __r_arr[37]; + let __v_100: G = __r_arr[38]; + let __v_101: G = __r_arr[39]; + let __v_102: G = __r_arr[40]; + let __v_103: G = __r_arr[41]; + let __v_104: G = __r_arr[42]; + let __v_105: G = __r_arr[43]; + let __v_106: G = __r_arr[44]; + let __v_107: G = __r_arr[45]; + let __v_108: G = __r_arr[46]; + let __v_109: G = __r_arr[47]; + let __v_110: G = G::from_u64(0); + let __v_111: G = { let __values: [G; 48] = [__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]; let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_112: G = { let __values: [G; 3] = [__v_110, __v_111, __v_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 } }; + match __v_62.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_130] = { let __args: [G; IN_130] = [__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]; let __cu = unconstrained; if let Some(result) = record.function_queries[130].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_130] = unsafe { *(result.output.as_ptr() as *const [G; OUT_130]) }; __ret } else { aiur_fn_130(__args, record, io_buffer, __cu)? } }; + let __v_113: G = __r_arr[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 = 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 = G::from_u64(0); + let __v_122: G = G::from_u64(0); + let __v_123: G = G::from_u64(0); + let __v_124: G = G::from_u64(0); + let __v_125: G = G::from_u64(0); + 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 __v_129: G = G::from_u64(0); + let __v_130: G = G::from_u64(0); + let __v_131: G = G::from_u64(0); + let __v_132: G = G::from_u64(0); + let __v_133: G = G::from_u64(0); + 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 __v_137: G = G::from_u64(0); + let __v_138: G = G::from_u64(0); + let __v_139: G = G::from_u64(0); + let __v_140: G = G::from_u64(0); + let __v_141: G = G::from_u64(0); + let __v_142: G = G::from_u64(0); + let __v_143: G = G::from_u64(0); + let __v_144: G = G::from_u64(0); + let __v_145: G = G::from_u64(0); + let __v_146: G = { let __values: [G; 32] = [__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, __v_138, __v_139, __v_140, __v_141, __v_142, __v_143, __v_144, __v_145]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_113, __v_146]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_147: G = __r_arr[0]; + match __v_147.as_canonical_u64() { + 1u64 => { + 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_714] = { let __args: [G; IN_714] = [__v_108, __v_150]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_151: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_151, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_152: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_152.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_153: G = __loaded[0]; + let __v_154: G = __loaded[1]; + let __v_155: G = __loaded[2]; + match __v_153.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_177] = [__v_54, __v_112]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_154, __v_155, __v_54, __v_112, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { 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_156: G = __r_arr[0]; + let __v_157: G = __r_arr[1]; + let __ret: [G; OUT_177] = [__v_156, __v_157]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_153.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __v_148: G = G::from_u64(0); + let __v_149: G = G::from_u64(1); + let __v_150: G = G::from_u64(1); + let __v_151: G = { let __values: [G; 3] = [__v_149, __v_150, __v_150]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_152: G = { let __values: [G; 3] = [__v_148, __v_113, __v_151]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_108, __v_152]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_153: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_153, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_154: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_154.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_155: G = __loaded[0]; + let __v_156: G = __loaded[1]; + let __v_157: G = __loaded[2]; + match __v_155.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_177] = [__v_54, __v_112]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_156, __v_157, __v_54, __v_112, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { 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_158: G = __r_arr[0]; + let __v_159: G = __r_arr[1]; + let __ret: [G; OUT_177] = [__v_158, __v_159]; + record.function_queries[177].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_155.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_147.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_178: usize = 1; +const IN_178: usize = 1; +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_178], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(1); + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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(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 = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { 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_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_13, __v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { 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_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __v_20: G = __r_arr[2]; + let __v_21: G = __r_arr[3]; + let __v_22: G = __r_arr[4]; + let __v_23: G = __r_arr[5]; + let __v_24: G = { let __values: [G; 6] = [__v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = G::from_u64(0); + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_13, __v_12, __v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { 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_26: G = __r_arr[0]; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_13, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_154] = unsafe { *(result.output.as_ptr() as *const [G; OUT_154]) }; __ret } else { aiur_fn_154(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = { let __values: [G; 6] = [__v_28, __v_29, __v_30, __v_31, __v_32, __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 __v_35: G = G::from_u64(0); + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_13, __v_12, __v_12, __v_27, __v_34, __v_24, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __ret: [G; OUT_178] = [__v_37]; + record.function_queries[178].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_179: usize = 5; +const IN_179: usize = 5; +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_179], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = (__v_0 - __v_1); + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 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_179] = [__v_8]; + record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_183] = { let __args: [G; IN_183] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[183].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_183] = unsafe { *(result.output.as_ptr() as *const [G; OUT_183]) }; __ret } else { aiur_fn_183(__args, record, io_buffer, __cu)? } }; + let __v_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 = (__v_0 + __v_8); + let __r_arr: [G; OUT_179] = { let __args: [G; IN_179] = [__v_9, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[179].get_mut(&__args[..]) { 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_10: G = __r_arr[0]; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_179] = [__v_11]; + record.function_queries[179].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_180: usize = 1; +const IN_180: usize = 1; +const OUT_180: usize = 1; +fn aiur_fn_180( + inp: [G; IN_180], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_180], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + let __v_48: G = __loaded[47]; + match __v_1.as_canonical_u64() { + _ => { + match __v_1.as_canonical_u64() { + 6u64 => { + let __v_49: G = G::from_u64(1); + let __ret: [G; OUT_180] = [__v_49]; + record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_49: G = G::from_u64(1); + let __ret: [G; OUT_180] = [__v_49]; + record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_49: G = G::from_u64(1); + let __ret: [G; OUT_180] = [__v_49]; + record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_49: G = G::from_u64(1); + let __ret: [G; OUT_180] = [__v_49]; + record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_49: G = G::from_u64(0); + let __ret: [G; OUT_180] = [__v_49]; + record.function_queries[180].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +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_181], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_181] = [__v_7, __v_40]; + record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_13: G = (__v_11 - __v_0); + let __v_14: G = G::from_bool((__v_13 == G::ZERO)); + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { 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_15: G = __r_arr[0]; + let __v_16: G = (__v_14 * __v_15); + match __v_16.as_canonical_u64() { + 1u64 => { + let __v_17: G = G::from_u64(1); + let __ret: [G; OUT_181] = [__v_17, __v_5]; + 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] = [__v_0, __v_6, __v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { 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_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __ret: [G; OUT_181] = [__v_17, __v_18]; + record.function_queries[181].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_182: usize = 3; +const IN_182: usize = 3; +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 = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = { let __values: [G; 32] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_38]; + record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_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 = (__v_7 - __v_0); + match __v_9.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_182] = [__v_4]; + record.function_queries[182].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_182] = [__v_10]; + record.function_queries[182].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_183: usize = 4; +const IN_183: usize = 4; +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 __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_181] = { let __args: [G; IN_181] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[181].get_mut(&__args[..]) { 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_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_183] = [__v_5]; + record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_182] = { let __args: [G; IN_182] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[182].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_182] = unsafe { *(result.output.as_ptr() as *const [G; OUT_182]) }; __ret } else { aiur_fn_182(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_183] = [__v_6]; + record.function_queries[183].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_184: usize = 10; +const IN_184: usize = 10; +const OUT_184: usize = 6; +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 __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_184] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; + record.function_queries[184].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_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + match __v_13.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + match __v_16.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_180] = { let __args: [G; IN_180] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[180].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; + let __v_20: G = (__v_19 - __v_3); + match __v_20.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_17, __v_11, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __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_184] = { let __args: [G; IN_184] = [__v_12, __v_15, __v_18, __v_3, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __v_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_184] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_12, __v_15, __v_18, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_184] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + record.function_queries[184].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_185: usize = 3; +const IN_185: usize = 3; +const OUT_185: usize = 6; +fn aiur_fn_185( + inp: [G; IN_185], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_185], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __v_9: G = __r_arr[3]; + let __v_10: G = __r_arr[4]; + let __v_11: G = __r_arr[5]; + let __v_12: G = G::from_u64(1); + let __r_arr: [G; OUT_184] = { let __args: [G; IN_184] = [__v_0, __v_1, __v_2, __v_12, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[184].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_184] = unsafe { *(result.output.as_ptr() as *const [G; OUT_184]) }; __ret } else { aiur_fn_184(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_185] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + record.function_queries[185].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_186: usize = 7; +const IN_186: usize = 7; +const OUT_186: usize = 6; +fn aiur_fn_186( + inp: [G; IN_186], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_186], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __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_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_186] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_8, __v_9, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __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_186] = { let __args: [G; IN_186] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { 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_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_186] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + record.function_queries[186].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_187: usize = 9; +const IN_187: usize = 9; +const OUT_187: usize = 1; +fn aiur_fn_187( + inp: [G; IN_187], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_187], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = (__v_1 - __v_0); + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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]; + record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_0 + __v_12); + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_13, __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[187].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = { let __values: [G; 3] = [__v_11, __v_10, __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_187] = [__v_15]; + record.function_queries[187].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_188: usize = 3; +const IN_188: usize = 3; +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 = 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; 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_188] = [__v_8]; + record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 48] = { let __mq = record.memory_queries.get_mut(&48).ok_or(ExecError::InvalidMemorySize(48))?; 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: 48 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 48] = __args[..48].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + let __v_11: G = __loaded[5]; + let __v_12: G = __loaded[6]; + let __v_13: G = __loaded[7]; + let __v_14: G = __loaded[8]; + let __v_15: G = __loaded[9]; + let __v_16: G = __loaded[10]; + let __v_17: G = __loaded[11]; + let __v_18: G = __loaded[12]; + let __v_19: G = __loaded[13]; + let __v_20: G = __loaded[14]; + let __v_21: G = __loaded[15]; + let __v_22: G = __loaded[16]; + let __v_23: G = __loaded[17]; + let __v_24: G = __loaded[18]; + let __v_25: G = __loaded[19]; + let __v_26: G = __loaded[20]; + let __v_27: G = __loaded[21]; + let __v_28: G = __loaded[22]; + let __v_29: G = __loaded[23]; + let __v_30: G = __loaded[24]; + let __v_31: G = __loaded[25]; + let __v_32: G = __loaded[26]; + let __v_33: G = __loaded[27]; + let __v_34: G = __loaded[28]; + let __v_35: G = __loaded[29]; + let __v_36: G = __loaded[30]; + let __v_37: G = __loaded[31]; + let __v_38: G = __loaded[32]; + let __v_39: G = __loaded[33]; + let __v_40: G = __loaded[34]; + let __v_41: G = __loaded[35]; + let __v_42: G = __loaded[36]; + let __v_43: G = __loaded[37]; + let __v_44: G = __loaded[38]; + let __v_45: G = __loaded[39]; + let __v_46: G = __loaded[40]; + let __v_47: G = __loaded[41]; + let __v_48: G = __loaded[42]; + let __v_49: G = __loaded[43]; + let __v_50: G = __loaded[44]; + let __v_51: G = __loaded[45]; + let __v_52: G = __loaded[46]; + let __v_53: G = __loaded[47]; + 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_54: G = __loaded[0]; + let __v_55: G = __loaded[1]; + let __v_56: G = __loaded[2]; + match __v_54.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + _ => { + match __v_6.as_canonical_u64() { + 6u64 => { + match __v_7.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_141] = { let __args: [G; IN_141] = [__v_15, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[141].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_141] = unsafe { *(result.output.as_ptr() as *const [G; OUT_141]) }; __ret } else { aiur_fn_141(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __v_59: G = __r_arr[1]; + let __v_60: G = __r_arr[2]; + let __v_61: G = __r_arr[3]; + let __v_62: G = __r_arr[4]; + let __v_63: G = __r_arr[5]; + let __v_64: G = __r_arr[6]; + let __v_65: G = __r_arr[7]; + let __v_66: G = __r_arr[8]; + let __v_67: G = __r_arr[9]; + let __v_68: G = __r_arr[10]; + let __v_69: G = __r_arr[11]; + let __v_70: G = __r_arr[12]; + let __v_71: G = __r_arr[13]; + let __v_72: G = __r_arr[14]; + let __v_73: G = __r_arr[15]; + let __v_74: G = __r_arr[16]; + let __v_75: G = __r_arr[17]; + let __v_76: G = __r_arr[18]; + let __v_77: G = __r_arr[19]; + let __v_78: G = __r_arr[20]; + let __v_79: G = __r_arr[21]; + let __v_80: G = __r_arr[22]; + let __v_81: G = __r_arr[23]; + let __v_82: G = __r_arr[24]; + let __v_83: G = __r_arr[25]; + let __v_84: G = __r_arr[26]; + let __v_85: G = __r_arr[27]; + let __v_86: G = __r_arr[28]; + let __v_87: G = __r_arr[29]; + let __v_88: G = __r_arr[30]; + let __v_89: G = __r_arr[31]; + let __v_90: G = __r_arr[32]; + let __v_91: G = __r_arr[33]; + let __v_92: G = __r_arr[34]; + let __v_93: G = __r_arr[35]; + let __v_94: G = __r_arr[36]; + let __v_95: G = __r_arr[37]; + let __v_96: G = __r_arr[38]; + let __v_97: G = __r_arr[39]; + let __v_98: G = __r_arr[40]; + let __v_99: G = __r_arr[41]; + let __v_100: G = __r_arr[42]; + let __v_101: G = __r_arr[43]; + let __v_102: G = __r_arr[44]; + let __v_103: G = __r_arr[45]; + let __v_104: G = __r_arr[46]; + let __v_105: G = __r_arr[47]; + match __v_58.as_canonical_u64() { + _ => { + match __v_58.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_106: G = __r_arr[0]; + let __r_arr: [G; OUT_133] = { let __args: [G; IN_133] = [__v_59, __v_106]; let __cu = unconstrained; if let Some(result) = record.function_queries[133].get_mut(&__args[..]) { 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_107: G = __r_arr[0]; + let __v_108: G = G::from_u64(1); + let __v_109: G = (__v_107 + __v_108); + let __v_110: G = (__v_57 + __v_109); + let __r_arr: [G; OUT_14] = { let __args: [G; IN_14] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[14].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_14] = unsafe { *(result.output.as_ptr() as *const [G; OUT_14]) }; __ret } else { aiur_fn_14(__args, record, io_buffer, __cu)? } }; + let __v_111: G = __r_arr[0]; + let __r_arr: [G; OUT_189] = { let __args: [G; IN_189] = [__v_59, __v_111]; let __cu = unconstrained; if let Some(result) = record.function_queries[189].get_mut(&__args[..]) { 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_112: G = __r_arr[0]; + let __v_113: G = G::from_u64(0); + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_110, __v_112, __v_113]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_114: G = __r_arr[0]; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { 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_115: G = __r_arr[0]; + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_114, __v_115]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __v_116: G = __r_arr[0]; + let __ret: [G; OUT_188] = [__v_116]; + record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { 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_106: G = __r_arr[0]; + let __ret: [G; OUT_188] = [__v_106]; + record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_5, __v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { 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_57: G = __r_arr[0]; + let __ret: [G; OUT_188] = [__v_57]; + record.function_queries[188].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_54.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_189: usize = 2; +const IN_189: usize = 2; +const OUT_189: usize = 1; +fn aiur_fn_189( + inp: [G; IN_189], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_189], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __ret: [G; OUT_189] = [__v_3]; + record.function_queries[189].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_190: usize = 3; +const IN_190: usize = 3; +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_190], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __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 }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + let __v_14: G = __loaded[11]; + let __v_15: G = __loaded[12]; + let __v_16: G = __loaded[13]; + let __v_17: G = __loaded[14]; + let __v_18: G = __loaded[15]; + let __v_19: G = __loaded[16]; + let __v_20: G = __loaded[17]; + let __v_21: G = __loaded[18]; + let __v_22: G = __loaded[19]; + let __v_23: G = __loaded[20]; + let __v_24: G = __loaded[21]; + let __v_25: G = __loaded[22]; + let __v_26: G = __loaded[23]; + let __v_27: G = __loaded[24]; + let __v_28: G = __loaded[25]; + let __v_29: G = __loaded[26]; + let __v_30: G = __loaded[27]; + let __v_31: G = __loaded[28]; + let __v_32: G = __loaded[29]; + let __v_33: G = __loaded[30]; + let __v_34: G = __loaded[31]; + let __v_35: G = __loaded[32]; + let __v_36: G = __loaded[33]; + let __v_37: G = __loaded[34]; + let __v_38: G = __loaded[35]; + let __v_39: G = __loaded[36]; + let __v_40: G = __loaded[37]; + let __v_41: G = __loaded[38]; + let __v_42: G = __loaded[39]; + let __v_43: G = __loaded[40]; + let __v_44: G = __loaded[41]; + let __v_45: G = __loaded[42]; + let __v_46: G = __loaded[43]; + let __v_47: G = __loaded[44]; + let __v_48: G = __loaded[45]; + let __v_49: G = __loaded[46]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_50: G = G::from_u64(0); + let __ret: [G; OUT_190] = [__v_50]; + record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_50: G = (__v_2 - __v_1); + match __v_50.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 1u64 => { + match __v_5.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __ret: [G; OUT_190] = [__v_51]; + record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_51: G = G::from_u64(0); + let __ret: [G; OUT_190] = [__v_51]; + record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_51: G = G::from_u64(1); + let __v_52: G = (__v_2 + __v_51); + let __r_arr: [G; OUT_190] = { let __args: [G; IN_190] = [__v_49, __v_1, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[190].get_mut(&__args[..]) { 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_53: G = __r_arr[0]; + let __ret: [G; OUT_190] = [__v_53]; + record.function_queries[190].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_191: usize = 12; +const IN_191: usize = 12; +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_191], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = (__v_10 - __v_11); + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_13: G = G::from_u64(1); + let __v_14: G = G::from_u64(1); + let __v_15: G = { let __values: [G; 4] = [__v_13, __v_14, __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_191] = [__v_15]; + record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_192] = { let __args: [G; IN_192] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_11, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[192].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_192] = unsafe { *(result.output.as_ptr() as *const [G; OUT_192]) }; __ret } else { aiur_fn_192(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + let __v_15: G = (__v_9 + __v_11); + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_11 + __v_16); + let __r_arr: [G; OUT_191] = { let __args: [G; IN_191] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[191].get_mut(&__args[..]) { 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_18: G = __r_arr[0]; + let __v_19: G = { let __values: [G; 4] = [__v_14, __v_15, __v_13, __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_191] = [__v_19]; + record.function_queries[191].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_192: usize = 10; +const IN_192: usize = 10; +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_192], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(4); + 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 = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = G::from_u64(1); + let __v_26: G = G::from_u64(1); + let __v_27: G = { let __values: [G; 3] = [__v_25, __v_26, __v_26]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_17, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_9, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_21, __v_24, __v_27, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __ret: [G; OUT_192] = [__v_32]; + record.function_queries[192].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_193: usize = 1; +const IN_193: usize = 1; +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_193], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(1); + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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(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 = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_0, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { 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_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __ret: [G; OUT_193] = [__v_14, __v_15]; + record.function_queries[193].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 = 2; +fn aiur_fn_194( + inp: [G; IN_194], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_194], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __ret: [G; OUT_194] = [__v_4, __v_5]; + record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __r_arr: [G; OUT_177] = { let __args: [G; IN_177] = [__v_2, __v_3, __v_6, __v_9, __v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[177].get_mut(&__args[..]) { 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_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_195] = { let __args: [G; IN_195] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[195].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_195] = unsafe { *(result.output.as_ptr() as *const [G; OUT_195]) }; __ret } else { aiur_fn_195(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __ret: [G; OUT_194] = [__v_14, __v_15]; + record.function_queries[194].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_195: usize = 2; +const IN_195: usize = 2; +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_195], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + let __r_arr: [G; OUT_146] = { let __args: [G; IN_146] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[146].get_mut(&__args[..]) { 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 __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __r_arr: [G; OUT_139] = { let __args: [G; IN_139] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[139].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_139] = unsafe { *(result.output.as_ptr() as *const [G; OUT_139]) }; __ret } else { aiur_fn_139(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __v_9: G = __r_arr[3]; + let __v_10: G = __r_arr[4]; + let __v_11: G = __r_arr[5]; + let __v_12: G = { let __values: [G; 6] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_148] = { let __args: [G; IN_148] = [__v_1, __v_0, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[148].get_mut(&__args[..]) { 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_14: G = __r_arr[0]; + let __r_arr: [G; OUT_154] = { let __args: [G; IN_154] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[154].get_mut(&__args[..]) { 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_15: G = __r_arr[0]; + let __r_arr: [G; OUT_156] = { let __args: [G; IN_156] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[156].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_156] = unsafe { *(result.output.as_ptr() as *const [G; OUT_156]) }; __ret } else { aiur_fn_156(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __v_19: G = __r_arr[3]; + let __v_20: G = __r_arr[4]; + let __v_21: G = __r_arr[5]; + let __v_22: G = { let __values: [G; 6] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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(0); + let __r_arr: [G; OUT_175] = { let __args: [G; IN_175] = [__v_1, __v_0, __v_0, __v_15, __v_22, __v_12, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[175].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_175] = unsafe { *(result.output.as_ptr() as *const [G; OUT_175]) }; __ret } else { aiur_fn_175(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_123] = { let __args: [G; IN_123] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[123].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_123] = unsafe { *(result.output.as_ptr() as *const [G; OUT_123]) }; __ret } else { aiur_fn_123(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_185] = { let __args: [G; IN_185] = [__v_0, __v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[185].get_mut(&__args[..]) { 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 __v_30: G = __r_arr[4]; + let __v_31: G = __r_arr[5]; + let __r_arr: [G; OUT_188] = { let __args: [G; IN_188] = [__v_1, __v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[188].get_mut(&__args[..]) { 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_32: G = __r_arr[0]; + let __r_arr: [G; OUT_186] = { let __args: [G; IN_186] = [__v_32, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[186].get_mut(&__args[..]) { 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_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 = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 32] = [__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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_72: G = G::from_u64(0); + let __r_arr: [G; OUT_187] = { let __args: [G; IN_187] = [__v_72, __v_5, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[187].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_187] = unsafe { *(result.output.as_ptr() as *const [G; OUT_187]) }; __ret } else { aiur_fn_187(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __r_arr: [G; OUT_196] = { let __args: [G; IN_196] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[196].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_196] = unsafe { *(result.output.as_ptr() as *const [G; OUT_196]) }; __ret } else { aiur_fn_196(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __v_75: G = __r_arr[1]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_25, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_73, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; + let __ret: [G; OUT_195] = [__v_76, __v_77]; + record.function_queries[195].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_196: usize = 0; +const IN_196: usize = 0; +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_196], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __r_arr: [G; OUT_197] = { let __args: [G; IN_197] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[197].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_197] = unsafe { *(result.output.as_ptr() as *const [G; OUT_197]) }; __ret } else { aiur_fn_197(__args, record, io_buffer, __cu)? } }; + let __v_0: G = __r_arr[0]; + let __v_1: G = G::from_u64(1); + 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_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = G::from_u64(0); + let __v_6: G = { let __values: [G; 4] = [__v_1, __v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 11] = [__v_7, __v_8, __v_6, __v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; 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 __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !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_12: G = __r_arr[0]; + 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 !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 __ret: [G; OUT_196] = [__v_13, __v_0]; + record.function_queries[196].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_197: usize = 0; +const IN_197: usize = 0; +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 = G::from_u64(0); + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = G::from_u64(0); + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { 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 = G::from_u64(0); + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { 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 __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_249] = { let __args: [G; IN_249] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(0); + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { 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]; + let __v_26: G = G::from_u64(0); + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { 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_27: G = __r_arr[0]; + let __v_28: G = G::from_u64(0); + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { 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(0); + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { 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_31: G = __r_arr[0]; + let __v_32: G = G::from_u64(0); + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = G::from_u64(0); + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = G::from_u64(0); + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = G::from_u64(0); + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { 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_39: G = __r_arr[0]; + let __v_40: G = G::from_u64(0); + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = G::from_u64(0); + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = G::from_u64(0); + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { 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_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(0); + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { 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_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(0); + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __v_52: G = G::from_u64(0); + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { 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_53: G = __r_arr[0]; + let __v_54: G = G::from_u64(0); + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { 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_55: G = __r_arr[0]; + let __v_56: G = G::from_u64(0); + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { 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_57: G = __r_arr[0]; + let __v_58: G = G::from_u64(0); + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { 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_59: G = __r_arr[0]; + let __v_60: G = G::from_u64(0); + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __v_62: G = G::from_u64(0); + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __v_64: G = G::from_u64(0); + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __v_66: G = G::from_u64(0); + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { 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_67: G = __r_arr[0]; + let __v_68: G = G::from_u64(0); + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __v_70: G = G::from_u64(0); + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __v_72: G = G::from_u64(0); + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __v_74: G = G::from_u64(0); + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { 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_75: G = __r_arr[0]; + let __v_76: G = G::from_u64(0); + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; + let __v_78: G = G::from_u64(0); + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __v_79: G = __r_arr[0]; + let __v_80: G = G::from_u64(0); + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_81: G = __r_arr[0]; + let __v_82: G = G::from_u64(0); + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __v_83: G = __r_arr[0]; + let __v_84: G = G::from_u64(0); + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_85: G = __r_arr[0]; + let __v_86: G = G::from_u64(0); + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { 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_87: G = __r_arr[0]; + let __v_88: G = G::from_u64(0); + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __v_89: G = __r_arr[0]; + let __v_90: G = G::from_u64(0); + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __v_91: G = __r_arr[0]; + let __v_92: G = G::from_u64(0); + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __v_93: G = __r_arr[0]; + let __v_94: G = G::from_u64(0); + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { 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_95: G = __r_arr[0]; + let __v_96: G = G::from_u64(0); + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __v_97: G = __r_arr[0]; + let __v_98: G = G::from_u64(0); + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __v_99: G = __r_arr[0]; + let __v_100: G = G::from_u64(0); + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __v_101: G = __r_arr[0]; + let __v_102: G = G::from_u64(0); + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __v_103: G = __r_arr[0]; + let __v_104: G = G::from_u64(0); + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __v_105: G = __r_arr[0]; + let __v_106: G = G::from_u64(0); + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __v_107: G = __r_arr[0]; + let __v_108: G = G::from_u64(0); + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __v_109: G = __r_arr[0]; + let __v_110: G = G::from_u64(0); + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __v_111: G = __r_arr[0]; + let __v_112: G = G::from_u64(0); + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __v_113: G = __r_arr[0]; + let __v_114: G = G::from_u64(0); + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __v_115: G = __r_arr[0]; + let __v_116: G = G::from_u64(0); + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __v_117: G = __r_arr[0]; + let __v_118: G = G::from_u64(0); + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __v_119: G = __r_arr[0]; + let __v_120: G = G::from_u64(0); + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __v_121: G = __r_arr[0]; + let __v_122: G = G::from_u64(0); + let __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __v_123: G = __r_arr[0]; + let __v_124: G = G::from_u64(0); + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __v_125: G = __r_arr[0]; + let __v_126: G = G::from_u64(0); + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __v_127: G = __r_arr[0]; + let __v_128: G = G::from_u64(0); + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __v_129: G = __r_arr[0]; + let __v_130: G = G::from_u64(0); + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __v_131: G = __r_arr[0]; + let __v_132: G = G::from_u64(0); + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __v_133: G = __r_arr[0]; + let __v_134: G = G::from_u64(0); + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __v_135: G = __r_arr[0]; + let __v_136: G = G::from_u64(0); + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_141: G = { let __values: [G; 3] = [__v_136, __v_137, __v_140]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_142: G = { let __values: [G; 3] = [__v_134, __v_135, __v_141]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_143: G = { let __values: [G; 3] = [__v_132, __v_133, __v_142]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_144: G = { let __values: [G; 3] = [__v_130, __v_131, __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 __v_145: G = { let __values: [G; 3] = [__v_128, __v_129, __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 __v_146: G = { let __values: [G; 3] = [__v_126, __v_127, __v_145]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_147: G = { let __values: [G; 3] = [__v_124, __v_125, __v_146]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_148: G = { let __values: [G; 3] = [__v_122, __v_123, __v_147]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_149: G = { let __values: [G; 3] = [__v_120, __v_121, __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 __v_150: G = { let __values: [G; 3] = [__v_118, __v_119, __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 __v_151: G = { let __values: [G; 3] = [__v_116, __v_117, __v_150]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_152: G = { let __values: [G; 3] = [__v_114, __v_115, __v_151]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_153: G = { let __values: [G; 3] = [__v_112, __v_113, __v_152]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_154: G = { let __values: [G; 3] = [__v_110, __v_111, __v_153]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_155: G = { let __values: [G; 3] = [__v_108, __v_109, __v_154]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_156: G = { let __values: [G; 3] = [__v_106, __v_107, __v_155]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_157: G = { let __values: [G; 3] = [__v_104, __v_105, __v_156]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_158: G = { let __values: [G; 3] = [__v_102, __v_103, __v_157]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_159: G = { let __values: [G; 3] = [__v_100, __v_101, __v_158]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_160: G = { let __values: [G; 3] = [__v_98, __v_99, __v_159]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_161: G = { let __values: [G; 3] = [__v_96, __v_97, __v_160]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_162: G = { let __values: [G; 3] = [__v_94, __v_95, __v_161]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_92, __v_93, __v_162]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_90, __v_91, __v_163]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_165: G = { let __values: [G; 3] = [__v_88, __v_89, __v_164]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_166: G = { let __values: [G; 3] = [__v_86, __v_87, __v_165]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_167: G = { let __values: [G; 3] = [__v_84, __v_85, __v_166]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_168: G = { let __values: [G; 3] = [__v_82, __v_83, __v_167]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_169: G = { let __values: [G; 3] = [__v_80, __v_81, __v_168]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_170: G = { let __values: [G; 3] = [__v_78, __v_79, __v_169]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_171: G = { let __values: [G; 3] = [__v_76, __v_77, __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 __v_172: G = { let __values: [G; 3] = [__v_74, __v_75, __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 __v_173: G = { let __values: [G; 3] = [__v_72, __v_73, __v_172]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_174: G = { let __values: [G; 3] = [__v_70, __v_71, __v_173]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_175: G = { let __values: [G; 3] = [__v_68, __v_69, __v_174]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_176: G = { let __values: [G; 3] = [__v_66, __v_67, __v_175]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_177: G = { let __values: [G; 3] = [__v_64, __v_65, __v_176]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_178: G = { let __values: [G; 3] = [__v_62, __v_63, __v_177]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_179: G = { let __values: [G; 3] = [__v_60, __v_61, __v_178]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_180: G = { let __values: [G; 3] = [__v_58, __v_59, __v_179]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_181: G = { let __values: [G; 3] = [__v_56, __v_57, __v_180]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_182: G = { let __values: [G; 3] = [__v_54, __v_55, __v_181]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_183: G = { let __values: [G; 3] = [__v_52, __v_53, __v_182]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_184: G = { let __values: [G; 3] = [__v_50, __v_51, __v_183]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_185: G = { let __values: [G; 3] = [__v_48, __v_49, __v_184]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_186: G = { let __values: [G; 3] = [__v_46, __v_47, __v_185]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_187: G = { let __values: [G; 3] = [__v_44, __v_45, __v_186]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_188: G = { let __values: [G; 3] = [__v_42, __v_43, __v_187]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_189: G = { let __values: [G; 3] = [__v_40, __v_41, __v_188]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_190: G = { let __values: [G; 3] = [__v_38, __v_39, __v_189]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_191: G = { let __values: [G; 3] = [__v_36, __v_37, __v_190]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_192: G = { let __values: [G; 3] = [__v_34, __v_35, __v_191]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_32, __v_33, __v_192]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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; 3] = [__v_30, __v_31, __v_193]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_195: G = { let __values: [G; 3] = [__v_28, __v_29, __v_194]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_196: G = { let __values: [G; 3] = [__v_26, __v_27, __v_195]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_197: G = { let __values: [G; 3] = [__v_24, __v_25, __v_196]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_198: G = { let __values: [G; 3] = [__v_22, __v_23, __v_197]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_199: G = { let __values: [G; 3] = [__v_20, __v_21, __v_198]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_200: G = { let __values: [G; 3] = [__v_18, __v_19, __v_199]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_201: G = { let __values: [G; 3] = [__v_16, __v_17, __v_200]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_202: G = { let __values: [G; 3] = [__v_14, __v_15, __v_201]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_203: G = { let __values: [G; 3] = [__v_12, __v_13, __v_202]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_204: G = { let __values: [G; 3] = [__v_10, __v_11, __v_203]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_205: G = { let __values: [G; 3] = [__v_8, __v_9, __v_204]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_206: G = { let __values: [G; 3] = [__v_6, __v_7, __v_205]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_207: G = { let __values: [G; 3] = [__v_4, __v_5, __v_206]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_208: G = { let __values: [G; 3] = [__v_2, __v_3, __v_207]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_209: G = { let __values: [G; 3] = [__v_0, __v_1, __v_208]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_209]; + record.function_queries[197].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_198: usize = 1; +const IN_198: usize = 1; +const OUT_198: usize = 1; +fn aiur_fn_198( + inp: [G; IN_198], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_198], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_198] = [__v_4]; + record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_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_198] = [__v_6]; + record.function_queries[198].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +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_199], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_199] = [__v_4]; + record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(1); + let __v_4: G = (__v_1 - __v_3); + let __r_arr: [G; OUT_199] = { let __args: [G; IN_199] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[199].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_199] = unsafe { *(result.output.as_ptr() as *const [G; OUT_199]) }; __ret } else { aiur_fn_199(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = { let __values: [G; 3] = [__v_2, __v_0, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_199] = [__v_6]; + record.function_queries[199].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +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_200], 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + match __v_1.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_200] = [__v_5, __v_7]; + record.function_queries[200].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_200] = [__v_0, __v_7]; + record.function_queries[200].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_201: usize = 3; +const IN_201: usize = 3; +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_201], ExecError> { + stacker::maybe_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 __v_3: G = G::from_u64(0); + let __ret: [G; OUT_201] = [__v_3]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_3: G = G::from_u64(0); + let __ret: [G; OUT_201] = [__v_3]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_201] = [__v_3]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { 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_10: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 0u64 => { + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_201] = [__v_11]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_201] = [__v_11]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_201] = [__v_11]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { 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_6: G = __r_arr[0]; + let __ret: [G; OUT_201] = [__v_6]; + record.function_queries[201].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_202: usize = 6; +const IN_202: usize = 6; +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_202], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_202] = [__v_6]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_202] = [__v_6]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __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]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_202] = [__v_12]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_202] = [__v_9]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 2u64 => { + 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_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + 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_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = (__v_18 * __v_19); + let __ret: [G; OUT_202] = [__v_20]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_202] = [__v_12]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 3u64 => { + 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_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + 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_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = (__v_18 * __v_19); + let __ret: [G; OUT_202] = [__v_20]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_202] = [__v_12]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + match __v_3.as_canonical_u64() { + 4u64 => { + let __v_6: G = (__v_1 - __v_4); + let __v_7: G = G::from_bool((__v_6 == G::ZERO)); + let __ret: [G; OUT_202] = [__v_7]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_202] = [__v_6]; + record.function_queries[202].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_203: usize = 2; +const IN_203: usize = 2; +const OUT_203: usize = 1; +fn aiur_fn_203( + inp: [G; IN_203], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_203], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_203] = [__v_8]; + record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_203] = [__v_8]; + record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_203] = [__v_8]; + record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(1); + let __ret: [G; OUT_203] = [__v_9]; + record.function_queries[203].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 __v_10: G = G::from_u64(2); + let __ret: [G; OUT_203] = [__v_10]; + record.function_queries[203].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { 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_10: G = __r_arr[0]; + let __ret: [G; OUT_203] = [__v_10]; + record.function_queries[203].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_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +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_204], 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 __ret: [G; OUT_204] = [__v_5]; + record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_204] = [__v_8]; + record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_204] = [__v_9]; + record.function_queries[204].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_204] = { let __args: [G; IN_204] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_204] = [__v_10]; + record.function_queries[204].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + 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 !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_10: G = __r_arr[0]; + let __ret: [G; OUT_204] = [__v_10]; + record.function_queries[204].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_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +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_205], 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_205] = [__v_8]; + record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_205] = [__v_8]; + record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_205] = [__v_8]; + record.function_queries[205].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + 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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_205] = unsafe { *(result.output.as_ptr() as *const [G; OUT_205]) }; __ret } else { aiur_fn_205(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_205] = [__v_8]; + record.function_queries[205].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_206: usize = 2; +const IN_206: usize = 2; +const OUT_206: usize = 2; +fn aiur_fn_206( + inp: [G; IN_206], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_206], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_0, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_206] = [__v_5, __v_10]; + record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_0, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_6, __v_8]; + record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_0.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_206] = [__v_7, __v_1]; + record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_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_206] = [__v_7, __v_10]; + record.function_queries[206].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_207: usize = 3; +const IN_207: usize = 3; +const OUT_207: usize = 1; +fn aiur_fn_207( + inp: [G; IN_207], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_207], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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_207] = [__v_11]; + record.function_queries[207].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_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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + match __v_6.as_canonical_u64() { + _ => { + let __v_8: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 2] = [__v_1, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_207] = [__v_11]; + record.function_queries[207].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_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_207] = { let __args: [G; IN_207] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __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_207] = [__v_12]; + record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_10.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 2] = [__v_6, __v_2]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_207] = [__v_13]; + record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_207] = [__v_0]; + record.function_queries[207].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_208: usize = 2; +const IN_208: usize = 2; +const OUT_208: usize = 1; +fn aiur_fn_208( + inp: [G; IN_208], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_208], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_208] = [__v_8]; + record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_208] = [__v_8]; + record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_208] = [__v_8]; + record.function_queries[208].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 = (__v_8 - __v_10); + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_13: G = (__v_9 - __v_11); + match __v_13.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_208] = [__v_14]; + record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_208] = [__v_14]; + record.function_queries[208].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_208] = [__v_13]; + record.function_queries[208].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_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_209], 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_209] = [__v_4]; + record.function_queries[209].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_209] = { let __args: [G; IN_209] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[209].get_mut(&__args[..]) { 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_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_209] = [__v_5]; + record.function_queries[209].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_209] = [__v_6]; + record.function_queries[209].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_210: usize = 2; +const IN_210: usize = 2; +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_210], 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_210] = [__v_0]; + record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_210] = [__v_0]; + record.function_queries[210].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_210] = { let __args: [G; IN_210] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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_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_210] = [__v_15]; + record.function_queries[210].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_210] = { let __args: [G; IN_210] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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_14: G = __r_arr[0]; + let __ret: [G; OUT_210] = [__v_14]; + record.function_queries[210].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_210] = { let __args: [G; IN_210] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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 = { 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_210] = [__v_17]; + record.function_queries[210].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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_15: G = __r_arr[0]; + let __ret: [G; OUT_210] = [__v_15]; + record.function_queries[210].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_211: usize = 3; +const IN_211: usize = 3; +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_211], ExecError> { + stacker::maybe_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_211] = [__v_0]; + record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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 __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_212] = unsafe { *(result.output.as_ptr() as *const [G; OUT_212]) }; __ret } else { aiur_fn_212(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_211] = [__v_6]; + record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_211] = [__v_0]; + record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __ret: [G; OUT_211] = [__v_3]; + record.function_queries[211].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_212: usize = 3; +const IN_212: usize = 3; +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_212], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = { let __values: [G; 3] = [__v_1, __v_2, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_6, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_212] = [__v_14]; + record.function_queries[212].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_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { 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]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_10.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 3] = [__v_6, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_212] = [__v_13]; + record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_212] = [__v_0]; + record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + 1u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_1, __v_2, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_10, __v_14, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_212] = [__v_15]; + record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_212] = { let __args: [G; IN_212] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[212].get_mut(&__args[..]) { 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 __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_212] = [__v_12]; + record.function_queries[212].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_213: usize = 4; +const IN_213: usize = 4; +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_213], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 3] = [__v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_1, __v_8, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = G::from_u64(1); + let __v_17: G = G::from_u64(1); + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __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_213] = [__v_19]; + record.function_queries[213].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_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_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { 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_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_207] = { let __args: [G; IN_207] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[207].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_207] = unsafe { *(result.output.as_ptr() as *const [G; OUT_207]) }; __ret } else { aiur_fn_207(__args, record, io_buffer, __cu)? } }; + let __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_213] = [__v_14]; + record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 2] = [__v_2, __v_3]; let __mq = record.memory_queries.get_mut(&2).ok_or(ExecError::InvalidMemorySize(2))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_13, __v_14, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = { let __values: [G; 3] = [__v_1, __v_12, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_20: G = { let __values: [G; 3] = [__v_11, __v_19, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_213] = [__v_20]; + record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_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_213] = [__v_13]; + record.function_queries[213].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_214: usize = 6; +const IN_214: usize = 6; +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 __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { 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_6: G = __r_arr[0]; + let __ret: [G; OUT_214] = [__v_6]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_4 + __v_9); + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_6, __v_7, __v_8, __v_3, __v_10, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_214] = [__v_11]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_6, __v_7, __v_8, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9, __v_10, __v_11, __v_3, __v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_214] = [__v_13]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_214] = [__v_12]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_5, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { 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_8: G = __r_arr[0]; + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_7, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_214] = [__v_9]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_214] = [__v_5]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_5, __v_3, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_214] = [__v_8]; + record.function_queries[214].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_215: usize = 9; +const IN_215: usize = 9; +const OUT_215: usize = 1; +fn aiur_fn_215( + inp: [G; IN_215], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_215], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_8, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { 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 __ret: [G; OUT_215] = [__v_9]; + record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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]; + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_7 + __v_12); + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_9, __v_10, __v_11, __v_6, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_215] = [__v_15]; + record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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]; + 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_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1, __v_2, __v_9, __v_10, __v_11, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1, __v_2, __v_12, __v_13, __v_14, __v_6, __v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_215] = [__v_16]; + record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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]; + 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_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_0, __v_1, __v_2, __v_12, __v_13, __v_14, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_215] = { let __args: [G; IN_215] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_6, __v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[215].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_215] = unsafe { *(result.output.as_ptr() as *const [G; OUT_215]) }; __ret } else { aiur_fn_215(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_215] = [__v_16]; + record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_206] = { let __args: [G; IN_206] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[206].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_206] = unsafe { *(result.output.as_ptr() as *const [G; OUT_206]) }; __ret } else { aiur_fn_206(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_211] = { let __args: [G; IN_211] = [__v_8, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[211].get_mut(&__args[..]) { 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_213] = { let __args: [G; IN_213] = [__v_11, __v_10, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_10, __v_7, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_215] = [__v_13]; + record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { + 0u64 => { + break '__mc_0 [__v_8]; + }, + _ => { + let __r_arr: [G; OUT_213] = { let __args: [G; IN_213] = [__v_8, __v_6, __v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[213].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_213] = unsafe { *(result.output.as_ptr() as *const [G; OUT_213]) }; __ret } else { aiur_fn_213(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + break '__mc_0 [__v_11]; + }, +} + }; + let __v_11: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_215] = [__v_12]; + record.function_queries[215].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +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_216], 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_216] = [__v_0]; + record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(0); + 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 !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_216] = { let __args: [G; IN_216] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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_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_216] = [__v_8]; + record.function_queries[216].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_217: usize = 2; +const IN_217: usize = 2; +const OUT_217: usize = 1; +fn aiur_fn_217( + inp: [G; IN_217], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_217], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_217] = [__v_0]; + record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_8, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_217] = { let __args: [G; IN_217] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !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_12: G = __r_arr[0]; + let __ret: [G; OUT_217] = [__v_12]; + 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] = [__v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[205].get_mut(&__args[..]) { 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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { + 0u64 => { + let __v_13: G = G::from_u64(0); + break '__mc_0 [__v_13]; + }, + _ => { + let __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_12.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(1); + break '__mc_1 [__v_13]; + }, + 0u64 => { + let __v_13: G = { let __a_val = __v_9.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + break '__mc_1 [__v_13]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, +} + }; + let __v_13: G = __mc_out___mc_1[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __mc_out___mc_2: [G; 1] = '__mc_2: { match __v_14.as_canonical_u64() { + 1u64 => { + let __v_17: G = G::from_u64(1); + break '__mc_2 [__v_17]; + }, + 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 !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 = (__v_17 + __v_18); + let __v_20: G = { let __a_val = __v_19.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + break '__mc_2 [__v_20]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, +} + }; + let __v_17: G = __mc_out___mc_2[0]; + let __v_18: G = (__v_13 * __v_17); + match __v_18.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(0); + break '__mc_0 [__v_19]; + }, + _ => { + break '__mc_0 [__v_6]; + }, + } + }, +} + }; + let __v_13: G = __mc_out___mc_0[0]; + let __mc_out___mc_3: [G; 1] = '__mc_3: { match __v_12.as_canonical_u64() { + 1u64 => { + break '__mc_3 [__v_7]; + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + match __v_14.as_canonical_u64() { + 1u64 => { + break '__mc_3 [__v_7]; + }, + 0u64 => { + let __r_arr: [G; OUT_210] = { let __args: [G; IN_210] = [__v_7, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[210].get_mut(&__args[..]) { 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_17: G = __r_arr[0]; + break '__mc_3 [__v_17]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, +} + }; + 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_217] = { let __args: [G; IN_217] = [__v_15, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[217].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_217] = unsafe { *(result.output.as_ptr() as *const [G; OUT_217]) }; __ret } else { aiur_fn_217(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_217] = [__v_16]; + record.function_queries[217].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +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_218], 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_218] = [__v_8]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_218] = [__v_8]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_218] = [__v_8]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + match __v_11.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_203] = { let __args: [G; IN_203] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[203].get_mut(&__args[..]) { 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_14: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_15: G = (__v_9 - __v_12); + match __v_15.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_208] = { let __args: [G; IN_208] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[208].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_208] = unsafe { *(result.output.as_ptr() as *const [G; OUT_208]) }; __ret } else { aiur_fn_208(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_218] = [__v_17]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_17: G = G::from_u64(0); + let __ret: [G; OUT_218] = [__v_17]; + record.function_queries[218].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + let __v_16: G = G::from_u64(0); + let __ret: [G; OUT_218] = [__v_16]; + record.function_queries[218].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]; + record.function_queries[218].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_219: usize = 3; +const IN_219: usize = 3; +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 __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_219] = [__v_6]; + record.function_queries[219].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_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_204] = { let __args: [G; IN_204] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[204].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_204] = unsafe { *(result.output.as_ptr() as *const [G; OUT_204]) }; __ret } else { aiur_fn_204(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_219] = [__v_10]; + record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_10.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(1); + break '__mc_0 [__v_11]; + }, + 1u64 => { + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_8, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + break '__mc_0 [__v_11]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, +} + }; + let __v_11: G = __mc_out___mc_0[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_219] = [__v_12]; + record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_219] = [__v_12]; + record.function_queries[219].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +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_220], 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(0); + let __ret: [G; OUT_220] = [__v_5]; + record.function_queries[220].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_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + match __v_5.as_canonical_u64() { + _ => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_6 + __v_7); + let __v_9: G = { let __a_val = __v_8.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(1); + let __ret: [G; OUT_220] = [__v_10]; + record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_220] = { let __args: [G; IN_220] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[220].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_220] = unsafe { *(result.output.as_ptr() as *const [G; OUT_220]) }; __ret } else { aiur_fn_220(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_220] = [__v_10]; + record.function_queries[220].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_221: usize = 4; +const IN_221: usize = 4; +const OUT_221: usize = 1; +fn aiur_fn_221( + inp: [G; IN_221], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_221], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_221] = [__v_7]; + record.function_queries[221].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_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_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_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 !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_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { 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_11: G = __r_arr[0]; + let __ret: [G; OUT_221] = [__v_11]; + record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { 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_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_221] = [__v_12]; + record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { 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 __ret: [G; OUT_221] = [__v_12]; + record.function_queries[221].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_222: usize = 3; +const IN_222: usize = 3; +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_222], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_222] = [__v_6]; + record.function_queries[222].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_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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + match __v_6.as_canonical_u64() { + _ => { + let __v_8: G = (__v_6 - __v_1); + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_9: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(1); + let __ret: [G; OUT_222] = [__v_10]; + record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { 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_10: G = __r_arr[0]; + let __ret: [G; OUT_222] = [__v_10]; + record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_222] = { let __args: [G; IN_222] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[222].get_mut(&__args[..]) { 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_9: G = __r_arr[0]; + let __ret: [G; OUT_222] = [__v_9]; + record.function_queries[222].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_223: usize = 2; +const IN_223: usize = 2; +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_223], 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 __ret: [G; OUT_223] = [__v_5]; + record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + _ => { + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_6.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(1); + break '__mc_0 [__v_8]; + }, + _ => { + let __r_arr: [G; OUT_219] = { let __args: [G; IN_219] = [__v_1, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[219].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_219] = unsafe { *(result.output.as_ptr() as *const [G; OUT_219]) }; __ret } else { aiur_fn_219(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + break '__mc_0 [__v_8]; + }, +} + }; + let __v_8: G = __mc_out___mc_0[0]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_223] = [__v_9]; + record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_7, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { 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_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_223] = [__v_10]; + record.function_queries[223].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { 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_10: G = __r_arr[0]; + let __ret: [G; OUT_223] = [__v_10]; + record.function_queries[223].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_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_224: usize = 3; +const IN_224: usize = 3; +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_224], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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 __ret: [G; OUT_224] = [__v_6]; + record.function_queries[224].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_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: 2 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 2] = __args[..2].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + match __v_6.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_221] = { let __args: [G; IN_221] = [__v_1, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[221].get_mut(&__args[..]) { 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_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_224] = [__v_9]; + record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_224] = { let __args: [G; IN_224] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[224].get_mut(&__args[..]) { 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_9: G = __r_arr[0]; + let __ret: [G; OUT_224] = [__v_9]; + record.function_queries[224].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_225: usize = 3; +const IN_225: usize = 3; +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_225], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_6, __v_7, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 3] = [__v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 3] = [__v_3, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = G::from_u64(1); + let __v_17: G = G::from_u64(1); + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_214] = { let __args: [G; IN_214] = [__v_0, __v_1, __v_2, __v_18, __v_19, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[214].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_214] = unsafe { *(result.output.as_ptr() as *const [G; OUT_214]) }; __ret } else { aiur_fn_214(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_216] = { let __args: [G; IN_216] = [__v_20, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[216].get_mut(&__args[..]) { 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_21: G = __r_arr[0]; + let __ret: [G; OUT_225] = [__v_21]; + record.function_queries[225].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_226: usize = 6; +const IN_226: usize = 6; +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_226], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_226] = [__v_7]; + record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_226] = [__v_7]; + record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_223] = { let __args: [G; IN_223] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[223].get_mut(&__args[..]) { 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_9: G = __r_arr[0]; + let __ret: [G; OUT_226] = [__v_9]; + record.function_queries[226].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_227: usize = 6; +const IN_227: usize = 6; +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_227], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_227] = [__v_7]; + record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_225] = { let __args: [G; IN_225] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[225].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_225] = unsafe { *(result.output.as_ptr() as *const [G; OUT_225]) }; __ret } else { aiur_fn_225(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_218] = { let __args: [G; IN_218] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[218].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_218] = unsafe { *(result.output.as_ptr() as *const [G; OUT_218]) }; __ret } else { aiur_fn_218(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_227] = [__v_9]; + record.function_queries[227].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_228: usize = 6; +const IN_228: usize = 6; +const OUT_228: usize = 3; +fn aiur_fn_228( + inp: [G; IN_228], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_228], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_228] = [__v_3, __v_4, __v_5]; + record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_228] = [__v_0, __v_1, __v_2]; + record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_228] = [__v_0, __v_1, __v_2]; + record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_0.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_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = G::from_u64(1); + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = { let __values: [G; 3] = [__v_14, __v_15, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_228] = [__v_13, __v_17, __v_18]; + record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_10: G = G::from_u64(2); + let __v_11: G = { let __values: [G; 3] = [__v_0, __v_1, __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_12: G = { let __values: [G; 3] = [__v_3, __v_4, __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_228] = [__v_10, __v_11, __v_12]; + record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_7: G = G::from_u64(2); + let __v_8: G = { let __values: [G; 3] = [__v_0, __v_1, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_3, __v_4, __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_228] = [__v_7, __v_8, __v_9]; + record.function_queries[228].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_229: usize = 6; +const IN_229: usize = 6; +const OUT_229: usize = 3; +fn aiur_fn_229( + inp: [G; IN_229], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_229], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_229] = [__v_6, __v_7, __v_7]; + record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __ret: [G; OUT_229] = [__v_6, __v_7, __v_8]; + record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_201] = { let __args: [G; IN_201] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { 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_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __v_9: G = __r_arr[2]; + let __ret: [G; OUT_229] = [__v_7, __v_8, __v_9]; + record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_229] = [__v_3, __v_4, __v_5]; + record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_229] = [__v_0, __v_1, __v_2]; + record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(3); + let __v_9: G = { let __values: [G; 3] = [__v_0, __v_1, __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 = { let __values: [G; 3] = [__v_3, __v_4, __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_229] = [__v_8, __v_9, __v_10]; + record.function_queries[229].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_230: usize = 3; +const IN_230: usize = 3; +const OUT_230: usize = 3; +fn aiur_fn_230( + inp: [G; IN_230], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_230], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_230] = [__v_3, __v_4, __v_4]; + record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_3: G = G::from_u64(4); + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_230] = [__v_3, __v_1, __v_4]; + record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = G::from_u64(1); + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { 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 __v_8: G = __r_arr[1]; + let __v_9: G = __r_arr[2]; + let __v_10: G = { let __values: [G; 3] = [__v_7, __v_8, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_230] = [__v_6, __v_10, __v_11]; + record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { 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 = __r_arr[1]; + let __v_11: G = __r_arr[2]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __ret: [G; OUT_230] = [__v_15, __v_16, __v_17]; + record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { 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 = __r_arr[1]; + let __v_11: G = __r_arr[2]; + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_230] = unsafe { *(result.output.as_ptr() as *const [G; OUT_230]) }; __ret } else { aiur_fn_230(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __v_17: G = __r_arr[2]; + let __ret: [G; OUT_230] = [__v_15, __v_16, __v_17]; + record.function_queries[230].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_231: usize = 4; +const IN_231: usize = 4; +const OUT_231: usize = 3; +fn aiur_fn_231( + inp: [G; IN_231], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_231], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_231] = [__v_4, __v_5, __v_5]; + record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = G::from_u64(1); + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { 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]; + let __v_10: G = __r_arr[2]; + let __v_11: G = { let __values: [G; 3] = [__v_8, __v_9, __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 = G::from_u64(0); + let __ret: [G; OUT_231] = [__v_7, __v_11, __v_12]; + record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __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_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { 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_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = __r_arr[2]; + let __r_arr: [G; OUT_228] = { let __args: [G; IN_228] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[228].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_228] = unsafe { *(result.output.as_ptr() as *const [G; OUT_228]) }; __ret } else { aiur_fn_228(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __ret: [G; OUT_231] = [__v_16, __v_17, __v_18]; + record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __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_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { 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_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_231] = unsafe { *(result.output.as_ptr() as *const [G; OUT_231]) }; __ret } else { aiur_fn_231(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = __r_arr[2]; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __ret: [G; OUT_231] = [__v_16, __v_17, __v_18]; + record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_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]; + let __ret: [G; OUT_231] = [__v_5, __v_6, __v_7]; + record.function_queries[231].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_232: usize = 2; +const IN_232: usize = 2; +const OUT_232: usize = 1; +fn aiur_fn_232( + inp: [G; IN_232], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_232], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_232] = [__v_7]; + record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_5, __v_6, __v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { 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_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __v_11: G = __r_arr[2]; + let __v_12: G = { let __values: [G; 3] = [__v_9, __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 __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = { let __values: [G; 3] = [__v_8, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_232] = [__v_14]; + record.function_queries[232].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_233: usize = 2; +const IN_233: usize = 2; +const OUT_233: usize = 1; +fn aiur_fn_233( + inp: [G; IN_233], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_233], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_233] = [__v_0]; + record.function_queries[233].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_234] = { let __args: [G; IN_234] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[234].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_234] = unsafe { *(result.output.as_ptr() as *const [G; OUT_234]) }; __ret } else { aiur_fn_234(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_233] = [__v_5]; + record.function_queries[233].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 = 1; +fn aiur_fn_234( + inp: [G; IN_234], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_234], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __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_234] = [__v_8]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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]; + let __v_9: G = G::from_u64(1); + let __r_arr: [G; OUT_231] = { let __args: [G; IN_231] = [__v_6, __v_7, __v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[231].get_mut(&__args[..]) { 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_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + let __v_13: G = { let __values: [G; 3] = [__v_10, __v_11, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 4] = [__v_9, __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_234] = [__v_15]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_6: G = G::from_u64(2); + let __r_arr: [G; OUT_232] = { let __args: [G; IN_232] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[232].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_232] = unsafe { *(result.output.as_ptr() as *const [G; OUT_232]) }; __ret } else { aiur_fn_232(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __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_234] = [__v_9]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_6: G = G::from_u64(3); + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_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_234] = [__v_10]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_6: G = G::from_u64(4); + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_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_234] = [__v_10]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_6: G = G::from_u64(5); + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_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_234] = [__v_10]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_6: G = G::from_u64(6); + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_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_234] = [__v_10]; + record.function_queries[234].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_234] = [__v_8]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __v_6: G = G::from_u64(8); + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_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_234] = [__v_8]; + record.function_queries[234].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_235: usize = 2; +const IN_235: usize = 2; +const OUT_235: usize = 1; +fn aiur_fn_235( + inp: [G; IN_235], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_235], 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 __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_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]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_22: G = G::from_u64(1); + let __ret: [G; OUT_235] = [__v_22]; + record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_22: G = G::from_u64(0); + let __ret: [G; OUT_235] = [__v_22]; + record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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]; + 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]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_22: G = G::from_u64(0); + let __ret: [G; OUT_235] = [__v_22]; + record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_6] = { let __args: [G; IN_6] = [__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[6].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_6] = unsafe { *(result.output.as_ptr() as *const [G; OUT_6]) }; __ret } else { aiur_fn_6(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + match __v_22.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_235] = [__v_23]; + record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_235] = [__v_23]; + record.function_queries[235].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_236: usize = 2; +const IN_236: usize = 2; +const OUT_236: usize = 1; +fn aiur_fn_236( + inp: [G; IN_236], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_236], 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_236] = [__v_8]; + record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_236] = [__v_8]; + record.function_queries[236].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 __v_8: G = G::from_u64(0); + let __ret: [G; OUT_236] = [__v_8]; + record.function_queries[236].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_236] = { let __args: [G; IN_236] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { 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_9: G = __r_arr[0]; + let __ret: [G; OUT_236] = [__v_9]; + record.function_queries[236].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_236] = [__v_9]; + record.function_queries[236].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_237: usize = 4; +const IN_237: usize = 4; +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_237], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_237] = [__v_4]; + record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_237] = [__v_4]; + record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 1u64 => { + match __v_2.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { 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_4: G = __r_arr[0]; + let __ret: [G; OUT_237] = [__v_4]; + record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_237] = [__v_4]; + record.function_queries[237].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_238: usize = 0; +const IN_238: usize = 0; +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_238], 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_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_238] = [__v_32]; + record.function_queries[238].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_239: usize = 0; +const IN_239: usize = 0; +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_239], 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_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_239] = [__v_32]; + record.function_queries[239].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_240: usize = 0; +const IN_240: usize = 0; +const OUT_240: usize = 1; +fn aiur_fn_240( + inp: [G; IN_240], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_240], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(170); + let __v_1: G = G::from_u64(87); + let __v_2: G = G::from_u64(232); + let __v_3: G = G::from_u64(195); + let __v_4: G = G::from_u64(244); + let __v_5: G = G::from_u64(249); + let __v_6: G = G::from_u64(225); + let __v_7: G = G::from_u64(207); + let __v_8: G = G::from_u64(107); + let __v_9: G = G::from_u64(2); + let __v_10: G = G::from_u64(160); + let __v_11: G = G::from_u64(56); + let __v_12: G = G::from_u64(172); + let __v_13: G = G::from_u64(21); + let __v_14: G = G::from_u64(129); + let __v_15: G = G::from_u64(152); + let __v_16: G = G::from_u64(195); + let __v_17: G = G::from_u64(175); + let __v_18: G = G::from_u64(75); + let __v_19: G = G::from_u64(40); + let __v_20: G = G::from_u64(214); + let __v_21: G = G::from_u64(28); + let __v_22: G = G::from_u64(234); + let __v_23: G = G::from_u64(121); + let __v_24: G = G::from_u64(149); + let __v_25: G = G::from_u64(191); + let __v_26: G = G::from_u64(92); + let __v_27: G = G::from_u64(167); + let __v_28: G = G::from_u64(199); + let __v_29: G = G::from_u64(184); + let __v_30: G = G::from_u64(44); + let __v_31: G = G::from_u64(41); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_32]; + record.function_queries[240].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_241: usize = 0; +const IN_241: usize = 0; +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_241], 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_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_241] = [__v_32]; + record.function_queries[241].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_242: usize = 0; +const IN_242: usize = 0; +const OUT_242: usize = 1; +fn aiur_fn_242( + inp: [G; IN_242], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_242], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(51); + let __v_1: G = G::from_u64(217); + let __v_2: G = G::from_u64(74); + let __v_3: G = G::from_u64(45); + let __v_4: G = G::from_u64(37); + let __v_5: G = G::from_u64(10); + let __v_6: G = G::from_u64(26); + let __v_7: G = G::from_u64(90); + let __v_8: G = G::from_u64(160); + let __v_9: G = G::from_u64(34); + let __v_10: G = G::from_u64(227); + let __v_11: G = G::from_u64(190); + let __v_12: G = G::from_u64(253); + let __v_13: G = G::from_u64(202); + let __v_14: G = G::from_u64(28); + let __v_15: G = G::from_u64(134); + let __v_16: G = G::from_u64(244); + let __v_17: G = G::from_u64(93); + let __v_18: G = G::from_u64(112); + let __v_19: G = G::from_u64(7); + let __v_20: G = G::from_u64(29); + let __v_21: G = G::from_u64(176); + let __v_22: G = G::from_u64(56); + let __v_23: G = G::from_u64(239); + let __v_24: G = G::from_u64(249); + let __v_25: G = G::from_u64(184); + let __v_26: G = G::from_u64(152); + let __v_27: G = G::from_u64(13); + let __v_28: G = G::from_u64(197); + let __v_29: G = G::from_u64(22); + let __v_30: G = G::from_u64(11); + let __v_31: G = G::from_u64(118); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_242] = [__v_32]; + record.function_queries[242].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_243: usize = 0; +const IN_243: usize = 0; +const OUT_243: usize = 1; +fn aiur_fn_243( + inp: [G; IN_243], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_243], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(249); + let __v_1: G = G::from_u64(66); + let __v_2: G = G::from_u64(113); + let __v_3: G = G::from_u64(72); + let __v_4: G = G::from_u64(47); + let __v_5: G = G::from_u64(253); + let __v_6: G = G::from_u64(253); + let __v_7: G = G::from_u64(120); + let __v_8: G = G::from_u64(2); + let __v_9: G = G::from_u64(212); + let __v_10: G = G::from_u64(46); + let __v_11: G = G::from_u64(34); + let __v_12: G = G::from_u64(39); + let __v_13: G = G::from_u64(28); + let __v_14: G = G::from_u64(137); + let __v_15: G = G::from_u64(226); + let __v_16: G = G::from_u64(29); + let __v_17: G = G::from_u64(238); + let __v_18: G = G::from_u64(69); + let __v_19: G = G::from_u64(107); + let __v_20: G = G::from_u64(5); + let __v_21: G = G::from_u64(8); + let __v_22: G = G::from_u64(89); + let __v_23: G = G::from_u64(197); + let __v_24: G = G::from_u64(209); + let __v_25: G = G::from_u64(46); + let __v_26: G = G::from_u64(61); + let __v_27: G = G::from_u64(29); + let __v_28: G = G::from_u64(105); + let __v_29: G = G::from_u64(155); + let __v_30: G = G::from_u64(180); + let __v_31: G = G::from_u64(234); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_243] = [__v_32]; + record.function_queries[243].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_244: usize = 0; +const IN_244: usize = 0; +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_244], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(42); + let __v_1: G = G::from_u64(203); + let __v_2: G = G::from_u64(137); + let __v_3: G = G::from_u64(66); + let __v_4: G = G::from_u64(243); + let __v_5: G = G::from_u64(88); + let __v_6: G = G::from_u64(125); + let __v_7: G = G::from_u64(10); + let __v_8: G = G::from_u64(235); + let __v_9: G = G::from_u64(241); + let __v_10: G = G::from_u64(121); + let __v_11: G = G::from_u64(93); + let __v_12: G = G::from_u64(249); + let __v_13: G = G::from_u64(4); + let __v_14: G = G::from_u64(38); + let __v_15: G = G::from_u64(234); + let __v_16: G = G::from_u64(255); + let __v_17: G = G::from_u64(84); + let __v_18: G = G::from_u64(231); + let __v_19: G = G::from_u64(243); + let __v_20: G = G::from_u64(204); + let __v_21: G = G::from_u64(206); + let __v_22: G = G::from_u64(54); + let __v_23: G = G::from_u64(197); + let __v_24: G = G::from_u64(137); + let __v_25: G = G::from_u64(213); + let __v_26: G = G::from_u64(209); + let __v_27: G = G::from_u64(71); + let __v_28: G = G::from_u64(22); + let __v_29: G = G::from_u64(167); + let __v_30: G = G::from_u64(143); + let __v_31: G = G::from_u64(173); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_244] = [__v_32]; + record.function_queries[244].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_245: usize = 0; +const IN_245: usize = 0; +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_245], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(6); + let __v_1: G = G::from_u64(138); + let __v_2: G = G::from_u64(136); + let __v_3: G = G::from_u64(65); + let __v_4: G = G::from_u64(14); + let __v_5: G = G::from_u64(244); + let __v_6: G = G::from_u64(69); + let __v_7: G = G::from_u64(211); + let __v_8: G = G::from_u64(26); + let __v_9: G = G::from_u64(229); + let __v_10: G = G::from_u64(142); + let __v_11: G = G::from_u64(14); + let __v_12: G = G::from_u64(17); + let __v_13: G = G::from_u64(179); + let __v_14: G = G::from_u64(104); + let __v_15: G = G::from_u64(65); + let __v_16: G = G::from_u64(67); + let __v_17: G = G::from_u64(228); + let __v_18: G = G::from_u64(114); + let __v_19: G = G::from_u64(40); + let __v_20: G = G::from_u64(139); + let __v_21: G = G::from_u64(212); + let __v_22: G = G::from_u64(168); + let __v_23: G = G::from_u64(132); + let __v_24: G = G::from_u64(213); + let __v_25: G = G::from_u64(249); + let __v_26: G = G::from_u64(40); + let __v_27: G = G::from_u64(195); + let __v_28: G = G::from_u64(210); + let __v_29: G = G::from_u64(1); + let __v_30: G = G::from_u64(155); + let __v_31: G = G::from_u64(236); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_245] = [__v_32]; + record.function_queries[245].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_246: usize = 0; +const IN_246: usize = 0; +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_246], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(244); + let __v_1: G = G::from_u64(205); + let __v_2: G = G::from_u64(188); + let __v_3: G = G::from_u64(94); + let __v_4: G = G::from_u64(217); + let __v_5: G = G::from_u64(161); + let __v_6: G = G::from_u64(171); + let __v_7: G = G::from_u64(89); + let __v_8: G = G::from_u64(40); + let __v_9: G = G::from_u64(249); + let __v_10: G = G::from_u64(147); + let __v_11: G = G::from_u64(31); + let __v_12: G = G::from_u64(92); + let __v_13: G = G::from_u64(35); + let __v_14: G = G::from_u64(144); + let __v_15: G = G::from_u64(35); + let __v_16: G = G::from_u64(158); + let __v_17: G = G::from_u64(127); + let __v_18: G = G::from_u64(71); + let __v_19: G = G::from_u64(223); + let __v_20: G = G::from_u64(109); + let __v_21: G = G::from_u64(32); + let __v_22: G = G::from_u64(232); + let __v_23: G = G::from_u64(78); + let __v_24: G = G::from_u64(164); + let __v_25: G = G::from_u64(101); + let __v_26: G = G::from_u64(201); + let __v_27: G = G::from_u64(112); + let __v_28: G = G::from_u64(123); + let __v_29: G = G::from_u64(132); + let __v_30: G = G::from_u64(205); + let __v_31: G = G::from_u64(193); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_246] = [__v_32]; + record.function_queries[246].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_247: usize = 0; +const IN_247: usize = 0; +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_247], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(1); + let __v_1: G = G::from_u64(216); + let __v_2: G = G::from_u64(113); + let __v_3: G = G::from_u64(188); + let __v_4: G = G::from_u64(223); + let __v_5: G = G::from_u64(178); + let __v_6: G = G::from_u64(231); + let __v_7: G = G::from_u64(105); + let __v_8: G = G::from_u64(225); + let __v_9: G = G::from_u64(172); + let __v_10: G = G::from_u64(160); + let __v_11: G = G::from_u64(14); + let __v_12: G = G::from_u64(122); + let __v_13: G = G::from_u64(59); + let __v_14: G = G::from_u64(58); + let __v_15: G = G::from_u64(33); + let __v_16: G = G::from_u64(168); + let __v_17: G = G::from_u64(217); + let __v_18: G = G::from_u64(2); + let __v_19: G = G::from_u64(204); + let __v_20: G = G::from_u64(39); + let __v_21: G = G::from_u64(55); + let __v_22: G = G::from_u64(7); + let __v_23: G = G::from_u64(200); + let __v_24: G = G::from_u64(146); + let __v_25: G = G::from_u64(235); + let __v_26: G = G::from_u64(134); + let __v_27: G = G::from_u64(123); + let __v_28: G = G::from_u64(127); + let __v_29: G = G::from_u64(199); + let __v_30: G = G::from_u64(138); + let __v_31: G = G::from_u64(226); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_247] = [__v_32]; + record.function_queries[247].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_248: usize = 0; +const IN_248: usize = 0; +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_248], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(100); + let __v_1: G = G::from_u64(5); + let __v_2: G = G::from_u64(164); + let __v_3: G = G::from_u64(85); + let __v_4: G = G::from_u64(186); + let __v_5: G = G::from_u64(112); + let __v_6: G = G::from_u64(194); + let __v_7: G = G::from_u64(178); + let __v_8: G = G::from_u64(23); + let __v_9: G = G::from_u64(156); + let __v_10: G = G::from_u64(121); + let __v_11: G = G::from_u64(102); + let __v_12: G = G::from_u64(198); + let __v_13: G = G::from_u64(246); + let __v_14: G = G::from_u64(16); + let __v_15: G = G::from_u64(191); + let __v_16: G = G::from_u64(52); + let __v_17: G = G::from_u64(23); + let __v_18: G = G::from_u64(189); + let __v_19: G = G::from_u64(15); + let __v_20: G = G::from_u64(61); + let __v_21: G = G::from_u64(210); + let __v_22: G = G::from_u64(186); + let __v_23: G = G::from_u64(122); + let __v_24: G = G::from_u64(82); + let __v_25: G = G::from_u64(37); + let __v_26: G = G::from_u64(51); + let __v_27: G = G::from_u64(194); + let __v_28: G = G::from_u64(205); + let __v_29: G = G::from_u64(158); + let __v_30: G = G::from_u64(29); + let __v_31: G = G::from_u64(11); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_248] = [__v_32]; + record.function_queries[248].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_249: usize = 0; +const IN_249: usize = 0; +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_249], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(156); + let __v_1: G = G::from_u64(10); + let __v_2: G = G::from_u64(242); + let __v_3: G = G::from_u64(163); + let __v_4: G = G::from_u64(147); + let __v_5: G = G::from_u64(203); + let __v_6: G = G::from_u64(92); + let __v_7: G = G::from_u64(8); + let __v_8: G = G::from_u64(53); + let __v_9: G = G::from_u64(228); + let __v_10: G = G::from_u64(78); + let __v_11: G = G::from_u64(96); + let __v_12: G = G::from_u64(228); + let __v_13: G = G::from_u64(195); + let __v_14: G = G::from_u64(230); + let __v_15: G = G::from_u64(142); + let __v_16: G = G::from_u64(235); + let __v_17: G = G::from_u64(38); + let __v_18: G = G::from_u64(111); + let __v_19: G = G::from_u64(209); + let __v_20: G = G::from_u64(106); + let __v_21: G = G::from_u64(255); + let __v_22: G = G::from_u64(173); + let __v_23: G = G::from_u64(50); + let __v_24: G = G::from_u64(22); + let __v_25: G = G::from_u64(9); + let __v_26: G = G::from_u64(106); + let __v_27: G = G::from_u64(53); + let __v_28: G = G::from_u64(254); + let __v_29: G = G::from_u64(145); + let __v_30: G = G::from_u64(185); + let __v_31: G = G::from_u64(193); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_249] = [__v_32]; + record.function_queries[249].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_250: usize = 0; +const IN_250: usize = 0; +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_250], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(30); + let __v_1: G = G::from_u64(37); + let __v_2: G = G::from_u64(17); + let __v_3: G = G::from_u64(152); + let __v_4: G = G::from_u64(243); + let __v_5: G = G::from_u64(6); + let __v_6: G = G::from_u64(37); + let __v_7: G = G::from_u64(98); + let __v_8: G = G::from_u64(142); + let __v_9: G = G::from_u64(46); + let __v_10: G = G::from_u64(176); + let __v_11: G = G::from_u64(152); + let __v_12: G = G::from_u64(63); + let __v_13: G = G::from_u64(123); + let __v_14: G = G::from_u64(233); + let __v_15: G = G::from_u64(239); + let __v_16: G = G::from_u64(232); + let __v_17: G = G::from_u64(215); + let __v_18: G = G::from_u64(25); + let __v_19: G = G::from_u64(161); + let __v_20: G = G::from_u64(4); + let __v_21: G = G::from_u64(168); + let __v_22: G = G::from_u64(97); + let __v_23: G = G::from_u64(242); + let __v_24: G = G::from_u64(190); + let __v_25: G = G::from_u64(242); + let __v_26: G = G::from_u64(244); + let __v_27: G = G::from_u64(126); + let __v_28: G = G::from_u64(171); + let __v_29: G = G::from_u64(238); + let __v_30: G = G::from_u64(212); + let __v_31: G = G::from_u64(249); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_250] = [__v_32]; + record.function_queries[250].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_251: usize = 0; +const IN_251: usize = 0; +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_251], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(226); + let __v_1: G = G::from_u64(216); + let __v_2: G = G::from_u64(41); + let __v_3: G = G::from_u64(46); + let __v_4: G = G::from_u64(26); + let __v_5: G = G::from_u64(223); + let __v_6: G = G::from_u64(84); + let __v_7: G = G::from_u64(176); + let __v_8: G = G::from_u64(211); + let __v_9: G = G::from_u64(147); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(132); + let __v_12: G = G::from_u64(119); + let __v_13: G = G::from_u64(24); + let __v_14: G = G::from_u64(220); + let __v_15: G = G::from_u64(137); + let __v_16: G = G::from_u64(166); + let __v_17: G = G::from_u64(51); + let __v_18: G = G::from_u64(50); + let __v_19: G = G::from_u64(232); + let __v_20: G = G::from_u64(243); + let __v_21: G = G::from_u64(27); + let __v_22: G = G::from_u64(65); + let __v_23: G = G::from_u64(201); + let __v_24: G = G::from_u64(232); + let __v_25: G = G::from_u64(15); + let __v_26: G = G::from_u64(140); + let __v_27: G = G::from_u64(154); + let __v_28: G = G::from_u64(32); + let __v_29: G = G::from_u64(23); + let __v_30: G = G::from_u64(39); + let __v_31: G = G::from_u64(141); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_251] = [__v_32]; + record.function_queries[251].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_252: usize = 0; +const IN_252: usize = 0; +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_252], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(134); + let __v_1: G = G::from_u64(41); + let __v_2: G = G::from_u64(81); + let __v_3: G = G::from_u64(150); + let __v_4: G = G::from_u64(50); + let __v_5: G = G::from_u64(225); + let __v_6: G = G::from_u64(140); + let __v_7: G = G::from_u64(73); + let __v_8: G = G::from_u64(9); + let __v_9: G = G::from_u64(121); + let __v_10: G = G::from_u64(54); + let __v_11: G = G::from_u64(252); + let __v_12: G = G::from_u64(34); + let __v_13: G = G::from_u64(12); + let __v_14: G = G::from_u64(158); + let __v_15: G = G::from_u64(3); + let __v_16: G = G::from_u64(214); + let __v_17: G = G::from_u64(38); + let __v_18: G = G::from_u64(63); + let __v_19: G = G::from_u64(221); + let __v_20: G = G::from_u64(235); + let __v_21: G = G::from_u64(164); + let __v_22: G = G::from_u64(70); + let __v_23: G = G::from_u64(42); + let __v_24: G = G::from_u64(245); + let __v_25: G = G::from_u64(183); + let __v_26: G = G::from_u64(23); + let __v_27: G = G::from_u64(221); + let __v_28: G = G::from_u64(17); + let __v_29: G = G::from_u64(228); + let __v_30: G = G::from_u64(190); + let __v_31: G = G::from_u64(244); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_252] = [__v_32]; + record.function_queries[252].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_253: usize = 0; +const IN_253: usize = 0; +const OUT_253: usize = 1; +fn aiur_fn_253( + inp: [G; IN_253], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_253], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(66); + let __v_1: G = G::from_u64(149); + let __v_2: G = G::from_u64(192); + let __v_3: G = G::from_u64(113); + let __v_4: G = G::from_u64(169); + let __v_5: G = G::from_u64(72); + let __v_6: G = G::from_u64(90); + let __v_7: G = G::from_u64(242); + let __v_8: G = G::from_u64(217); + let __v_9: G = G::from_u64(152); + let __v_10: G = G::from_u64(227); + let __v_11: G = G::from_u64(148); + let __v_12: G = G::from_u64(123); + let __v_13: G = G::from_u64(229); + let __v_14: G = G::from_u64(152); + let __v_15: G = G::from_u64(128); + let __v_16: G = G::from_u64(119); + let __v_17: G = G::from_u64(83); + let __v_18: G = G::from_u64(31); + let __v_19: G = G::from_u64(2); + let __v_20: G = G::from_u64(191); + let __v_21: G = G::from_u64(9); + let __v_22: G = G::from_u64(27); + let __v_23: G = G::from_u64(135); + let __v_24: G = G::from_u64(13); + let __v_25: G = G::from_u64(83); + let __v_26: G = G::from_u64(206); + let __v_27: G = G::from_u64(88); + let __v_28: G = G::from_u64(157); + let __v_29: G = G::from_u64(78); + let __v_30: G = G::from_u64(245); + let __v_31: G = G::from_u64(177); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_253] = [__v_32]; + record.function_queries[253].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_254: usize = 0; +const IN_254: usize = 0; +const OUT_254: usize = 1; +fn aiur_fn_254( + inp: [G; IN_254], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_254], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(25); + let __v_1: G = G::from_u64(224); + let __v_2: G = G::from_u64(27); + let __v_3: G = G::from_u64(201); + let __v_4: G = G::from_u64(163); + let __v_5: G = G::from_u64(38); + let __v_6: G = G::from_u64(75); + let __v_7: G = G::from_u64(155); + let __v_8: G = G::from_u64(139); + let __v_9: G = G::from_u64(148); + let __v_10: G = G::from_u64(12); + let __v_11: G = G::from_u64(241); + let __v_12: G = G::from_u64(114); + let __v_13: G = G::from_u64(162); + let __v_14: G = G::from_u64(9); + let __v_15: G = G::from_u64(187); + let __v_16: G = G::from_u64(119); + let __v_17: G = G::from_u64(74); + let __v_18: G = G::from_u64(211); + let __v_19: G = G::from_u64(111); + let __v_20: G = G::from_u64(100); + let __v_21: G = G::from_u64(16); + let __v_22: G = G::from_u64(250); + let __v_23: G = G::from_u64(116); + let __v_24: G = G::from_u64(47); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(72); + let __v_27: G = G::from_u64(4); + let __v_28: G = G::from_u64(104); + let __v_29: G = G::from_u64(8); + let __v_30: G = G::from_u64(192); + let __v_31: G = G::from_u64(182); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_254] = [__v_32]; + record.function_queries[254].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_255: usize = 0; +const IN_255: usize = 0; +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_255], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(126); + let __v_1: G = G::from_u64(4); + let __v_2: G = G::from_u64(142); + let __v_3: G = G::from_u64(243); + let __v_4: G = G::from_u64(3); + let __v_5: G = G::from_u64(236); + let __v_6: G = G::from_u64(220); + let __v_7: G = G::from_u64(131); + let __v_8: G = G::from_u64(100); + let __v_9: G = G::from_u64(103); + let __v_10: G = G::from_u64(205); + let __v_11: G = G::from_u64(212); + let __v_12: G = G::from_u64(216); + let __v_13: G = G::from_u64(146); + let __v_14: G = G::from_u64(247); + let __v_15: G = G::from_u64(254); + let __v_16: G = G::from_u64(38); + let __v_17: G = G::from_u64(251); + let __v_18: G = G::from_u64(189); + let __v_19: G = G::from_u64(123); + let __v_20: G = G::from_u64(98); + let __v_21: G = G::from_u64(174); + let __v_22: G = G::from_u64(29); + let __v_23: G = G::from_u64(23); + let __v_24: G = G::from_u64(70); + let __v_25: G = G::from_u64(84); + let __v_26: G = G::from_u64(63); + let __v_27: G = G::from_u64(78); + let __v_28: G = G::from_u64(48); + let __v_29: G = G::from_u64(152); + let __v_30: G = G::from_u64(198); + let __v_31: G = G::from_u64(225); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_255] = [__v_32]; + record.function_queries[255].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_256: usize = 0; +const IN_256: usize = 0; +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_256], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(108); + let __v_1: G = G::from_u64(194); + let __v_2: G = G::from_u64(214); + let __v_3: G = G::from_u64(61); + let __v_4: G = G::from_u64(161); + let __v_5: G = G::from_u64(253); + let __v_6: G = G::from_u64(7); + let __v_7: G = G::from_u64(226); + let __v_8: G = G::from_u64(83); + let __v_9: G = G::from_u64(63); + let __v_10: G = G::from_u64(203); + let __v_11: G = G::from_u64(8); + let __v_12: G = G::from_u64(203); + let __v_13: G = G::from_u64(179); + let __v_14: G = G::from_u64(140); + let __v_15: G = G::from_u64(45); + let __v_16: G = G::from_u64(103); + let __v_17: G = G::from_u64(247); + let __v_18: G = G::from_u64(81); + let __v_19: G = G::from_u64(42); + let __v_20: G = G::from_u64(126); + let __v_21: G = G::from_u64(253); + let __v_22: G = G::from_u64(21); + let __v_23: G = G::from_u64(35); + let __v_24: G = G::from_u64(106); + let __v_25: G = G::from_u64(75); + let __v_26: G = G::from_u64(14); + let __v_27: G = G::from_u64(87); + let __v_28: G = G::from_u64(187); + let __v_29: G = G::from_u64(31); + let __v_30: G = G::from_u64(205); + let __v_31: G = G::from_u64(83); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_256] = [__v_32]; + record.function_queries[256].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_257: usize = 0; +const IN_257: usize = 0; +const OUT_257: usize = 1; +fn aiur_fn_257( + inp: [G; IN_257], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_257], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(70); + let __v_1: G = G::from_u64(181); + let __v_2: G = G::from_u64(235); + let __v_3: G = G::from_u64(103); + let __v_4: G = G::from_u64(104); + let __v_5: G = G::from_u64(193); + let __v_6: G = G::from_u64(244); + let __v_7: G = G::from_u64(149); + let __v_8: G = G::from_u64(135); + let __v_9: G = G::from_u64(214); + let __v_10: G = G::from_u64(83); + let __v_11: G = G::from_u64(193); + let __v_12: G = G::from_u64(46); + let __v_13: G = G::from_u64(55); + let __v_14: G = G::from_u64(51); + let __v_15: G = G::from_u64(137); + let __v_16: G = G::from_u64(18); + let __v_17: G = G::from_u64(21); + let __v_18: G = G::from_u64(51); + let __v_19: G = G::from_u64(134); + let __v_20: G = G::from_u64(131); + let __v_21: G = G::from_u64(47); + let __v_22: G = G::from_u64(15); + let __v_23: G = G::from_u64(208); + let __v_24: G = G::from_u64(228); + let __v_25: G = G::from_u64(114); + let __v_26: G = G::from_u64(72); + let __v_27: G = G::from_u64(78); + let __v_28: G = G::from_u64(38); + let __v_29: G = G::from_u64(50); + let __v_30: G = G::from_u64(38); + let __v_31: G = G::from_u64(50); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_257] = [__v_32]; + record.function_queries[257].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_258: usize = 0; +const IN_258: usize = 0; +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_258], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(37); + let __v_1: G = G::from_u64(187); + let __v_2: G = G::from_u64(205); + let __v_3: G = G::from_u64(117); + let __v_4: G = G::from_u64(107); + let __v_5: G = G::from_u64(82); + let __v_6: G = G::from_u64(235); + let __v_7: G = G::from_u64(120); + let __v_8: G = G::from_u64(188); + let __v_9: G = G::from_u64(225); + let __v_10: G = G::from_u64(112); + let __v_11: G = G::from_u64(65); + let __v_12: G = G::from_u64(13); + let __v_13: G = G::from_u64(239); + let __v_14: G = G::from_u64(164); + let __v_15: G = G::from_u64(193); + let __v_16: G = G::from_u64(91); + let __v_17: G = G::from_u64(35); + let __v_18: G = G::from_u64(141); + let __v_19: G = G::from_u64(237); + let __v_20: G = G::from_u64(239); + let __v_21: G = G::from_u64(95); + let __v_22: G = G::from_u64(123); + let __v_23: G = G::from_u64(137); + let __v_24: G = G::from_u64(105); + let __v_25: G = G::from_u64(22); + let __v_26: G = G::from_u64(33); + let __v_27: G = G::from_u64(220); + let __v_28: G = G::from_u64(190); + let __v_29: G = G::from_u64(145); + let __v_30: G = G::from_u64(151); + let __v_31: G = G::from_u64(128); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_258] = [__v_32]; + record.function_queries[258].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_259: usize = 0; +const IN_259: usize = 0; +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_259], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(39); + let __v_1: G = G::from_u64(42); + let __v_2: G = G::from_u64(169); + let __v_3: G = G::from_u64(225); + let __v_4: G = G::from_u64(108); + let __v_5: G = G::from_u64(3); + let __v_6: G = G::from_u64(233); + let __v_7: G = G::from_u64(173); + let __v_8: G = G::from_u64(115); + let __v_9: G = G::from_u64(55); + let __v_10: G = G::from_u64(231); + let __v_11: G = G::from_u64(6); + let __v_12: G = G::from_u64(215); + let __v_13: G = G::from_u64(62); + let __v_14: G = G::from_u64(253); + let __v_15: G = G::from_u64(20); + let __v_16: G = G::from_u64(204); + let __v_17: G = G::from_u64(241); + let __v_18: G = G::from_u64(218); + let __v_19: G = G::from_u64(16); + let __v_20: G = G::from_u64(226); + let __v_21: G = G::from_u64(248); + let __v_22: G = G::from_u64(54); + let __v_23: G = G::from_u64(125); + let __v_24: G = G::from_u64(211); + let __v_25: G = G::from_u64(67); + let __v_26: G = G::from_u64(116); + let __v_27: G = G::from_u64(182); + let __v_28: G = G::from_u64(14); + let __v_29: G = G::from_u64(21); + let __v_30: G = G::from_u64(86); + let __v_31: G = G::from_u64(250); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_259] = [__v_32]; + record.function_queries[259].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_260: usize = 0; +const IN_260: usize = 0; +const OUT_260: usize = 1; +fn aiur_fn_260( + inp: [G; IN_260], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_260], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(122); + let __v_1: G = G::from_u64(24); + let __v_2: G = G::from_u64(202); + let __v_3: G = G::from_u64(132); + let __v_4: G = G::from_u64(161); + let __v_5: G = G::from_u64(19); + let __v_6: G = G::from_u64(176); + let __v_7: G = G::from_u64(194); + let __v_8: G = G::from_u64(173); + let __v_9: G = G::from_u64(12); + let __v_10: G = G::from_u64(192); + let __v_11: G = G::from_u64(232); + let __v_12: G = G::from_u64(37); + let __v_13: G = G::from_u64(165); + let __v_14: G = G::from_u64(93); + let __v_15: G = G::from_u64(118); + let __v_16: G = G::from_u64(126); + let __v_17: G = G::from_u64(119); + let __v_18: G = G::from_u64(168); + let __v_19: G = G::from_u64(158); + let __v_20: G = G::from_u64(141); + let __v_21: G = G::from_u64(14); + let __v_22: G = G::from_u64(29); + let __v_23: G = G::from_u64(130); + let __v_24: G = G::from_u64(235); + let __v_25: G = G::from_u64(145); + let __v_26: G = G::from_u64(4); + let __v_27: G = G::from_u64(133); + let __v_28: G = G::from_u64(159); + let __v_29: G = G::from_u64(83); + let __v_30: G = G::from_u64(208); + let __v_31: G = G::from_u64(149); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_260] = [__v_32]; + record.function_queries[260].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_261: usize = 0; +const IN_261: usize = 0; +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_261], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(58); + let __v_1: G = G::from_u64(226); + let __v_2: G = G::from_u64(199); + let __v_3: G = G::from_u64(29); + let __v_4: G = G::from_u64(162); + let __v_5: G = G::from_u64(191); + let __v_6: G = G::from_u64(52); + let __v_7: G = G::from_u64(23); + let __v_8: G = G::from_u64(154); + let __v_9: G = G::from_u64(90); + let __v_10: G = G::from_u64(136); + let __v_11: G = G::from_u64(8); + let __v_12: G = G::from_u64(133); + let __v_13: G = G::from_u64(124); + let __v_14: G = G::from_u64(52); + let __v_15: G = G::from_u64(163); + let __v_16: G = G::from_u64(183); + let __v_17: G = G::from_u64(102); + let __v_18: G = G::from_u64(47); + let __v_19: G = G::from_u64(245); + let __v_20: G = G::from_u64(101); + let __v_21: G = G::from_u64(77); + let __v_22: G = G::from_u64(140); + let __v_23: G = G::from_u64(36); + let __v_24: G = G::from_u64(124); + let __v_25: G = G::from_u64(67); + let __v_26: G = G::from_u64(232); + let __v_27: G = G::from_u64(90); + let __v_28: G = G::from_u64(124); + let __v_29: G = G::from_u64(222); + let __v_30: G = G::from_u64(73); + let __v_31: G = G::from_u64(63); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_261] = [__v_32]; + record.function_queries[261].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_262: usize = 0; +const IN_262: usize = 0; +const OUT_262: usize = 1; +fn aiur_fn_262( + inp: [G; IN_262], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_262], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(16); + let __v_1: G = G::from_u64(172); + let __v_2: G = G::from_u64(95); + let __v_3: G = G::from_u64(72); + let __v_4: G = G::from_u64(121); + let __v_5: G = G::from_u64(139); + let __v_6: G = G::from_u64(63); + let __v_7: G = G::from_u64(240); + let __v_8: G = G::from_u64(27); + let __v_9: G = G::from_u64(15); + let __v_10: G = G::from_u64(116); + let __v_11: G = G::from_u64(192); + let __v_12: G = G::from_u64(181); + let __v_13: G = G::from_u64(68); + let __v_14: G = G::from_u64(210); + let __v_15: G = G::from_u64(39); + let __v_16: G = G::from_u64(150); + let __v_17: G = G::from_u64(201); + let __v_18: G = G::from_u64(119); + let __v_19: G = G::from_u64(95); + let __v_20: G = G::from_u64(109); + let __v_21: G = G::from_u64(67); + let __v_22: G = G::from_u64(211); + let __v_23: G = G::from_u64(40); + let __v_24: G = G::from_u64(49); + let __v_25: G = G::from_u64(107); + let __v_26: G = G::from_u64(187); + let __v_27: G = G::from_u64(58); + let __v_28: G = G::from_u64(161); + let __v_29: G = G::from_u64(99); + let __v_30: G = G::from_u64(137); + let __v_31: G = G::from_u64(153); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_262] = [__v_32]; + record.function_queries[262].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_263: usize = 0; +const IN_263: usize = 0; +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_263], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(186); + let __v_1: G = G::from_u64(179); + let __v_2: G = G::from_u64(122); + let __v_3: G = G::from_u64(139); + let __v_4: G = G::from_u64(217); + let __v_5: G = G::from_u64(134); + let __v_6: G = G::from_u64(13); + let __v_7: G = G::from_u64(59); + let __v_8: G = G::from_u64(254); + let __v_9: G = G::from_u64(49); + let __v_10: G = G::from_u64(241); + let __v_11: G = G::from_u64(161); + let __v_12: G = G::from_u64(117); + let __v_13: G = G::from_u64(47); + let __v_14: G = G::from_u64(231); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(138); + let __v_17: G = G::from_u64(34); + let __v_18: G = G::from_u64(76); + let __v_19: G = G::from_u64(106); + let __v_20: G = G::from_u64(216); + let __v_21: G = G::from_u64(175); + let __v_22: G = G::from_u64(98); + let __v_23: G = G::from_u64(60); + let __v_24: G = G::from_u64(127); + let __v_25: G = G::from_u64(184); + let __v_26: G = G::from_u64(189); + let __v_27: G = G::from_u64(25); + let __v_28: G = G::from_u64(43); + let __v_29: G = G::from_u64(229); + let __v_30: G = G::from_u64(192); + let __v_31: G = G::from_u64(126); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_263] = [__v_32]; + record.function_queries[263].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_264: usize = 0; +const IN_264: usize = 0; +const OUT_264: usize = 1; +fn aiur_fn_264( + inp: [G; IN_264], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_264], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(152); + let __v_1: G = G::from_u64(27); + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(183); + let __v_4: G = G::from_u64(196); + let __v_5: G = G::from_u64(88); + let __v_6: G = G::from_u64(153); + let __v_7: G = G::from_u64(247); + let __v_8: G = G::from_u64(38); + let __v_9: G = G::from_u64(195); + let __v_10: G = G::from_u64(222); + let __v_11: G = G::from_u64(53); + let __v_12: G = G::from_u64(50); + let __v_13: G = G::from_u64(128); + let __v_14: G = G::from_u64(116); + let __v_15: G = G::from_u64(203); + let __v_16: G = G::from_u64(63); + let __v_17: G = G::from_u64(114); + let __v_18: G = G::from_u64(160); + let __v_19: G = G::from_u64(146); + let __v_20: G = G::from_u64(37); + let __v_21: G = G::from_u64(116); + let __v_22: G = G::from_u64(61); + let __v_23: G = G::from_u64(168); + let __v_24: G = G::from_u64(31); + let __v_25: G = G::from_u64(80); + let __v_26: G = G::from_u64(49); + let __v_27: G = G::from_u64(255); + let __v_28: G = G::from_u64(110); + let __v_29: G = G::from_u64(100); + let __v_30: G = G::from_u64(123); + let __v_31: G = G::from_u64(169); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_264] = [__v_32]; + record.function_queries[264].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_265: usize = 0; +const IN_265: usize = 0; +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_265], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(165); + let __v_1: G = G::from_u64(123); + let __v_2: G = G::from_u64(129); + let __v_3: G = G::from_u64(128); + let __v_4: G = G::from_u64(40); + let __v_5: G = G::from_u64(135); + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(206); + let __v_8: G = G::from_u64(191); + let __v_9: G = G::from_u64(177); + let __v_10: G = G::from_u64(214); + let __v_11: G = G::from_u64(221); + let __v_12: G = G::from_u64(41); + let __v_13: G = G::from_u64(241); + let __v_14: G = G::from_u64(96); + let __v_15: G = G::from_u64(204); + let __v_16: G = G::from_u64(74); + let __v_17: G = G::from_u64(204); + let __v_18: G = G::from_u64(60); + let __v_19: G = G::from_u64(106); + let __v_20: G = G::from_u64(186); + let __v_21: G = G::from_u64(152); + let __v_22: G = G::from_u64(52); + let __v_23: G = G::from_u64(228); + let __v_24: G = G::from_u64(107); + let __v_25: G = G::from_u64(101); + let __v_26: G = G::from_u64(241); + let __v_27: G = G::from_u64(197); + let __v_28: G = G::from_u64(170); + let __v_29: G = G::from_u64(114); + let __v_30: G = G::from_u64(23); + let __v_31: G = G::from_u64(226); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_265] = [__v_32]; + record.function_queries[265].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_266: usize = 0; +const IN_266: usize = 0; +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_266], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(110); + let __v_1: G = G::from_u64(155); + let __v_2: G = G::from_u64(60); + let __v_3: G = G::from_u64(28); + let __v_4: G = G::from_u64(165); + let __v_5: G = G::from_u64(217); + let __v_6: G = G::from_u64(240); + let __v_7: G = G::from_u64(155); + let __v_8: G = G::from_u64(144); + let __v_9: G = G::from_u64(35); + let __v_10: G = G::from_u64(33); + let __v_11: G = G::from_u64(177); + let __v_12: G = G::from_u64(85); + let __v_13: G = G::from_u64(237); + let __v_14: G = G::from_u64(244); + let __v_15: G = G::from_u64(82); + let __v_16: G = G::from_u64(76); + let __v_17: G = G::from_u64(62); + let __v_18: G = G::from_u64(50); + let __v_19: G = G::from_u64(222); + let __v_20: G = G::from_u64(29); + let __v_21: G = G::from_u64(105); + let __v_22: G = G::from_u64(13); + let __v_23: G = G::from_u64(185); + let __v_24: G = G::from_u64(23); + let __v_25: G = G::from_u64(191); + let __v_26: G = G::from_u64(186); + let __v_27: G = G::from_u64(170); + let __v_28: G = G::from_u64(172); + let __v_29: G = G::from_u64(63); + let __v_30: G = G::from_u64(143); + let __v_31: G = G::from_u64(130); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_266] = [__v_32]; + record.function_queries[266].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_267: usize = 0; +const IN_267: usize = 0; +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_267], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(110); + let __v_1: G = G::from_u64(69); + let __v_2: G = G::from_u64(58); + let __v_3: G = G::from_u64(124); + let __v_4: G = G::from_u64(237); + let __v_5: G = G::from_u64(175); + let __v_6: G = G::from_u64(226); + let __v_7: G = G::from_u64(237); + let __v_8: G = G::from_u64(187); + let __v_9: G = G::from_u64(193); + let __v_10: G = G::from_u64(240); + let __v_11: G = G::from_u64(80); + let __v_12: G = G::from_u64(52); + let __v_13: G = G::from_u64(66); + let __v_14: G = G::from_u64(190); + let __v_15: G = G::from_u64(73); + let __v_16: G = G::from_u64(158); + let __v_17: G = G::from_u64(76); + let __v_18: G = G::from_u64(191); + let __v_19: G = G::from_u64(24); + let __v_20: G = G::from_u64(166); + let __v_21: G = G::from_u64(192); + let __v_22: G = G::from_u64(13); + let __v_23: G = G::from_u64(201); + let __v_24: G = G::from_u64(159); + let __v_25: G = G::from_u64(57); + let __v_26: G = G::from_u64(3); + let __v_27: G = G::from_u64(238); + let __v_28: G = G::from_u64(127); + let __v_29: G = G::from_u64(5); + let __v_30: G = G::from_u64(219); + let __v_31: G = G::from_u64(175); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_267] = [__v_32]; + record.function_queries[267].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_268: usize = 0; +const IN_268: usize = 0; +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_268], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(84); + let __v_1: G = G::from_u64(25); + let __v_2: G = G::from_u64(24); + let __v_3: G = G::from_u64(127); + let __v_4: G = G::from_u64(191); + let __v_5: G = G::from_u64(103); + let __v_6: G = G::from_u64(239); + let __v_7: G = G::from_u64(28); + let __v_8: G = G::from_u64(79); + let __v_9: G = G::from_u64(249); + let __v_10: G = G::from_u64(171); + let __v_11: G = G::from_u64(11); + let __v_12: G = G::from_u64(225); + let __v_13: G = G::from_u64(176); + let __v_14: G = G::from_u64(29); + let __v_15: G = G::from_u64(70); + let __v_16: G = G::from_u64(49); + let __v_17: G = G::from_u64(162); + let __v_18: G = G::from_u64(112); + let __v_19: G = G::from_u64(100); + let __v_20: G = G::from_u64(127); + let __v_21: G = G::from_u64(254); + let __v_22: G = G::from_u64(67); + let __v_23: G = G::from_u64(75); + let __v_24: G = G::from_u64(247); + let __v_25: G = G::from_u64(225); + let __v_26: G = G::from_u64(247); + let __v_27: G = G::from_u64(136); + let __v_28: G = G::from_u64(179); + let __v_29: G = G::from_u64(200); + let __v_30: G = G::from_u64(29); + let __v_31: G = G::from_u64(212); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_268] = [__v_32]; + record.function_queries[268].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_269: usize = 0; +const IN_269: usize = 0; +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_269], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(212); + let __v_1: G = G::from_u64(131); + let __v_2: G = G::from_u64(150); + let __v_3: G = G::from_u64(100); + let __v_4: G = G::from_u64(56); + let __v_5: G = G::from_u64(173); + let __v_6: G = G::from_u64(71); + let __v_7: G = G::from_u64(206); + let __v_8: G = G::from_u64(65); + let __v_9: G = G::from_u64(85); + let __v_10: G = G::from_u64(179); + let __v_11: G = G::from_u64(72); + let __v_12: G = G::from_u64(88); + let __v_13: G = G::from_u64(25); + let __v_14: G = G::from_u64(163); + let __v_15: G = G::from_u64(119); + let __v_16: G = G::from_u64(226); + let __v_17: G = G::from_u64(38); + let __v_18: G = G::from_u64(5); + let __v_19: G = G::from_u64(181); + let __v_20: G = G::from_u64(154); + let __v_21: G = G::from_u64(26); + let __v_22: G = G::from_u64(175); + let __v_23: G = G::from_u64(208); + let __v_24: G = G::from_u64(182); + let __v_25: G = G::from_u64(129); + let __v_26: G = G::from_u64(203); + let __v_27: G = G::from_u64(56); + let __v_28: G = G::from_u64(172); + let __v_29: G = G::from_u64(168); + let __v_30: G = G::from_u64(49); + let __v_31: G = G::from_u64(7); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_269] = [__v_32]; + record.function_queries[269].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_270: usize = 0; +const IN_270: usize = 0; +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_270], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(173); + let __v_1: G = G::from_u64(68); + let __v_2: G = G::from_u64(201); + let __v_3: G = G::from_u64(4); + let __v_4: G = G::from_u64(73); + let __v_5: G = G::from_u64(250); + let __v_6: G = G::from_u64(248); + let __v_7: G = G::from_u64(111); + let __v_8: G = G::from_u64(99); + let __v_9: G = G::from_u64(193); + let __v_10: G = G::from_u64(112); + let __v_11: G = G::from_u64(240); + let __v_12: G = G::from_u64(146); + let __v_13: G = G::from_u64(226); + let __v_14: G = G::from_u64(36); + let __v_15: G = G::from_u64(155); + let __v_16: G = G::from_u64(204); + let __v_17: G = G::from_u64(171); + let __v_18: G = G::from_u64(30); + let __v_19: G = G::from_u64(116); + let __v_20: G = G::from_u64(28); + let __v_21: G = G::from_u64(31); + let __v_22: G = G::from_u64(225); + let __v_23: G = G::from_u64(13); + let __v_24: G = G::from_u64(248); + let __v_25: G = G::from_u64(76); + let __v_26: G = G::from_u64(149); + let __v_27: G = G::from_u64(180); + let __v_28: G = G::from_u64(75); + let __v_29: G = G::from_u64(56); + let __v_30: G = G::from_u64(67); + let __v_31: G = G::from_u64(113); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_270] = [__v_32]; + record.function_queries[270].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_271: usize = 0; +const IN_271: usize = 0; +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_271], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(173); + let __v_1: G = G::from_u64(88); + let __v_2: G = G::from_u64(195); + let __v_3: G = G::from_u64(101); + let __v_4: G = G::from_u64(96); + let __v_5: G = G::from_u64(68); + let __v_6: G = G::from_u64(215); + let __v_7: G = G::from_u64(250); + let __v_8: G = G::from_u64(239); + let __v_9: G = G::from_u64(105); + let __v_10: G = G::from_u64(118); + let __v_11: G = G::from_u64(55); + let __v_12: G = G::from_u64(245); + let __v_13: G = G::from_u64(22); + let __v_14: G = G::from_u64(215); + let __v_15: G = G::from_u64(38); + let __v_16: G = G::from_u64(116); + let __v_17: G = G::from_u64(211); + let __v_18: G = G::from_u64(91); + let __v_19: G = G::from_u64(24); + let __v_20: G = G::from_u64(102); + let __v_21: G = G::from_u64(60); + let __v_22: G = G::from_u64(178); + let __v_23: G = G::from_u64(99); + let __v_24: G = G::from_u64(247); + let __v_25: G = G::from_u64(204); + let __v_26: G = G::from_u64(202); + let __v_27: G = G::from_u64(140); + let __v_28: G = G::from_u64(221); + let __v_29: G = G::from_u64(46); + let __v_30: G = G::from_u64(111); + let __v_31: G = G::from_u64(0); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_271] = [__v_32]; + record.function_queries[271].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_272: usize = 0; +const IN_272: usize = 0; +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_272], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(72); + let __v_1: G = G::from_u64(145); + let __v_2: G = G::from_u64(135); + let __v_3: G = G::from_u64(233); + let __v_4: G = G::from_u64(205); + let __v_5: G = G::from_u64(3); + let __v_6: G = G::from_u64(171); + let __v_7: G = G::from_u64(235); + let __v_8: G = G::from_u64(193); + let __v_9: G = G::from_u64(42); + let __v_10: G = G::from_u64(19); + let __v_11: G = G::from_u64(53); + let __v_12: G = G::from_u64(198); + let __v_13: G = G::from_u64(40); + let __v_14: G = G::from_u64(214); + let __v_15: G = G::from_u64(66); + let __v_16: G = G::from_u64(234); + let __v_17: G = G::from_u64(42); + let __v_18: G = G::from_u64(72); + let __v_19: G = G::from_u64(189); + let __v_20: G = G::from_u64(194); + let __v_21: G = G::from_u64(98); + let __v_22: G = G::from_u64(200); + let __v_23: G = G::from_u64(95); + let __v_24: G = G::from_u64(132); + let __v_25: G = G::from_u64(143); + let __v_26: G = G::from_u64(16); + let __v_27: G = G::from_u64(17); + let __v_28: G = G::from_u64(231); + let __v_29: G = G::from_u64(63); + let __v_30: G = G::from_u64(97); + let __v_31: G = G::from_u64(10); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_272] = [__v_32]; + record.function_queries[272].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_273: usize = 0; +const IN_273: usize = 0; +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_273], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(113); + let __v_1: G = G::from_u64(5); + let __v_2: G = G::from_u64(234); + let __v_3: G = G::from_u64(244); + let __v_4: G = G::from_u64(197); + let __v_5: G = G::from_u64(44); + let __v_6: G = G::from_u64(227); + let __v_7: G = G::from_u64(161); + let __v_8: G = G::from_u64(147); + let __v_9: G = G::from_u64(114); + let __v_10: G = G::from_u64(168); + let __v_11: G = G::from_u64(127); + let __v_12: G = G::from_u64(172); + let __v_13: G = G::from_u64(87); + let __v_14: G = G::from_u64(168); + let __v_15: G = G::from_u64(249); + let __v_16: G = G::from_u64(89); + let __v_17: G = G::from_u64(138); + let __v_18: G = G::from_u64(36); + let __v_19: G = G::from_u64(99); + let __v_20: G = G::from_u64(52); + let __v_21: G = G::from_u64(206); + let __v_22: G = G::from_u64(110); + let __v_23: G = G::from_u64(255); + let __v_24: G = G::from_u64(174); + let __v_25: G = G::from_u64(227); + let __v_26: G = G::from_u64(228); + let __v_27: G = G::from_u64(142); + let __v_28: G = G::from_u64(126); + let __v_29: G = G::from_u64(109); + let __v_30: G = G::from_u64(58); + let __v_31: G = G::from_u64(173); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_273] = [__v_32]; + record.function_queries[273].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_274: usize = 0; +const IN_274: usize = 0; +const OUT_274: usize = 1; +fn aiur_fn_274( + inp: [G; IN_274], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_274], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(22); + let __v_1: G = G::from_u64(162); + let __v_2: G = G::from_u64(220); + let __v_3: G = G::from_u64(118); + let __v_4: G = G::from_u64(162); + let __v_5: G = G::from_u64(207); + let __v_6: G = G::from_u64(204); + let __v_7: G = G::from_u64(148); + let __v_8: G = G::from_u64(64); + let __v_9: G = G::from_u64(244); + let __v_10: G = G::from_u64(67); + let __v_11: G = G::from_u64(198); + let __v_12: G = G::from_u64(102); + let __v_13: G = G::from_u64(83); + let __v_14: G = G::from_u64(111); + let __v_15: G = G::from_u64(47); + let __v_16: G = G::from_u64(169); + let __v_17: G = G::from_u64(156); + let __v_18: G = G::from_u64(2); + let __v_19: G = G::from_u64(80); + let __v_20: G = G::from_u64(182); + let __v_21: G = G::from_u64(66); + let __v_22: G = G::from_u64(253); + let __v_23: G = G::from_u64(57); + let __v_24: G = G::from_u64(113); + let __v_25: G = G::from_u64(251); + let __v_26: G = G::from_u64(173); + let __v_27: G = G::from_u64(37); + let __v_28: G = G::from_u64(213); + let __v_29: G = G::from_u64(49); + let __v_30: G = G::from_u64(38); + let __v_31: G = G::from_u64(42); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_274] = [__v_32]; + record.function_queries[274].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_275: usize = 0; +const IN_275: usize = 0; +const OUT_275: usize = 1; +fn aiur_fn_275( + inp: [G; IN_275], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_275], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(33); + let __v_1: G = G::from_u64(27); + let __v_2: G = G::from_u64(245); + let __v_3: G = G::from_u64(237); + let __v_4: G = G::from_u64(47); + let __v_5: G = G::from_u64(76); + let __v_6: G = G::from_u64(81); + let __v_7: G = G::from_u64(212); + let __v_8: G = G::from_u64(87); + let __v_9: G = G::from_u64(80); + let __v_10: G = G::from_u64(231); + let __v_11: G = G::from_u64(91); + let __v_12: G = G::from_u64(137); + let __v_13: G = G::from_u64(31); + let __v_14: G = G::from_u64(162); + let __v_15: G = G::from_u64(103); + let __v_16: G = G::from_u64(219); + let __v_17: G = G::from_u64(77); + let __v_18: G = G::from_u64(78); + let __v_19: G = G::from_u64(111); + let __v_20: G = G::from_u64(70); + let __v_21: G = G::from_u64(194); + let __v_22: G = G::from_u64(7); + let __v_23: G = G::from_u64(146); + let __v_24: G = G::from_u64(130); + let __v_25: G = G::from_u64(250); + let __v_26: G = G::from_u64(43); + let __v_27: G = G::from_u64(227); + let __v_28: G = G::from_u64(232); + let __v_29: G = G::from_u64(135); + let __v_30: G = G::from_u64(129); + let __v_31: G = G::from_u64(161); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_275] = [__v_32]; + record.function_queries[275].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_276: usize = 0; +const IN_276: usize = 0; +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_276], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(252); + let __v_1: G = G::from_u64(14); + let __v_2: G = G::from_u64(30); + let __v_3: G = G::from_u64(145); + let __v_4: G = G::from_u64(47); + let __v_5: G = G::from_u64(45); + let __v_6: G = G::from_u64(127); + let __v_7: G = G::from_u64(18); + let __v_8: G = G::from_u64(4); + let __v_9: G = G::from_u64(154); + let __v_10: G = G::from_u64(91); + let __v_11: G = G::from_u64(49); + let __v_12: G = G::from_u64(93); + let __v_13: G = G::from_u64(118); + let __v_14: G = G::from_u64(238); + let __v_15: G = G::from_u64(194); + let __v_16: G = G::from_u64(149); + let __v_17: G = G::from_u64(98); + let __v_18: G = G::from_u64(227); + let __v_19: G = G::from_u64(77); + let __v_20: G = G::from_u64(195); + let __v_21: G = G::from_u64(158); + let __v_22: G = G::from_u64(188); + let __v_23: G = G::from_u64(162); + let __v_24: G = G::from_u64(82); + let __v_25: G = G::from_u64(135); + let __v_26: G = G::from_u64(174); + let __v_27: G = G::from_u64(88); + let __v_28: G = G::from_u64(128); + let __v_29: G = G::from_u64(125); + let __v_30: G = G::from_u64(177); + let __v_31: G = G::from_u64(55); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_276] = [__v_32]; + record.function_queries[276].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_277: usize = 0; +const IN_277: usize = 0; +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_277], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(250); + let __v_1: G = G::from_u64(200); + let __v_2: G = G::from_u64(47); + let __v_3: G = G::from_u64(13); + let __v_4: G = G::from_u64(37); + let __v_5: G = G::from_u64(85); + let __v_6: G = G::from_u64(214); + let __v_7: G = G::from_u64(166); + let __v_8: G = G::from_u64(62); + let __v_9: G = G::from_u64(27); + let __v_10: G = G::from_u64(138); + let __v_11: G = G::from_u64(31); + let __v_12: G = G::from_u64(232); + let __v_13: G = G::from_u64(216); + let __v_14: G = G::from_u64(107); + let __v_15: G = G::from_u64(210); + let __v_16: G = G::from_u64(147); + let __v_17: G = G::from_u64(25); + let __v_18: G = G::from_u64(127); + let __v_19: G = G::from_u64(57); + let __v_20: G = G::from_u64(195); + let __v_21: G = G::from_u64(150); + let __v_22: G = G::from_u64(253); + let __v_23: G = G::from_u64(194); + let __v_24: G = G::from_u64(60); + let __v_25: G = G::from_u64(18); + let __v_26: G = G::from_u64(117); + let __v_27: G = G::from_u64(198); + let __v_28: G = G::from_u64(15); + let __v_29: G = G::from_u64(24); + let __v_30: G = G::from_u64(43); + let __v_31: G = G::from_u64(55); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_277] = [__v_32]; + record.function_queries[277].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_278: usize = 0; +const IN_278: usize = 0; +const OUT_278: usize = 1; +fn aiur_fn_278( + inp: [G; IN_278], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_278], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(113); + let __v_1: G = G::from_u64(144); + let __v_2: G = G::from_u64(206); + let __v_3: G = G::from_u64(86); + let __v_4: G = G::from_u64(246); + let __v_5: G = G::from_u64(162); + let __v_6: G = G::from_u64(168); + let __v_7: G = G::from_u64(71); + let __v_8: G = G::from_u64(185); + let __v_9: G = G::from_u64(68); + let __v_10: G = G::from_u64(163); + let __v_11: G = G::from_u64(85); + let __v_12: G = G::from_u64(227); + let __v_13: G = G::from_u64(236); + let __v_14: G = G::from_u64(89); + let __v_15: G = G::from_u64(90); + let __v_16: G = G::from_u64(64); + let __v_17: G = G::from_u64(54); + let __v_18: G = G::from_u64(251); + let __v_19: G = G::from_u64(7); + let __v_20: G = G::from_u64(227); + let __v_21: G = G::from_u64(195); + let __v_22: G = G::from_u64(219); + let __v_23: G = G::from_u64(157); + let __v_24: G = G::from_u64(144); + let __v_25: G = G::from_u64(100); + let __v_26: G = G::from_u64(252); + let __v_27: G = G::from_u64(4); + let __v_28: G = G::from_u64(27); + let __v_29: G = G::from_u64(231); + let __v_30: G = G::from_u64(43); + let __v_31: G = G::from_u64(100); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_278] = [__v_32]; + record.function_queries[278].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_279: usize = 0; +const IN_279: usize = 0; +const OUT_279: usize = 1; +fn aiur_fn_279( + inp: [G; IN_279], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_279], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(78); + let __v_1: G = G::from_u64(213); + let __v_2: G = G::from_u64(255); + let __v_3: G = G::from_u64(251); + let __v_4: G = G::from_u64(3); + let __v_5: G = G::from_u64(174); + let __v_6: G = G::from_u64(94); + let __v_7: G = G::from_u64(107); + let __v_8: G = G::from_u64(122); + let __v_9: G = G::from_u64(13); + let __v_10: G = G::from_u64(159); + let __v_11: G = G::from_u64(51); + let __v_12: G = G::from_u64(121); + let __v_13: G = G::from_u64(170); + let __v_14: G = G::from_u64(118); + let __v_15: G = G::from_u64(158); + let __v_16: G = G::from_u64(92); + let __v_17: G = G::from_u64(168); + let __v_18: G = G::from_u64(24); + let __v_19: G = G::from_u64(140); + let __v_20: G = G::from_u64(172); + let __v_21: G = G::from_u64(189); + let __v_22: G = G::from_u64(241); + let __v_23: G = G::from_u64(226); + let __v_24: G = G::from_u64(13); + let __v_25: G = G::from_u64(202); + let __v_26: G = G::from_u64(75); + let __v_27: G = G::from_u64(173); + let __v_28: G = G::from_u64(39); + let __v_29: G = G::from_u64(242); + let __v_30: G = G::from_u64(83); + let __v_31: G = G::from_u64(51); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_279] = [__v_32]; + record.function_queries[279].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_280: usize = 0; +const IN_280: usize = 0; +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_280], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(157); + let __v_1: G = G::from_u64(131); + let __v_2: G = G::from_u64(48); + let __v_3: G = G::from_u64(125); + let __v_4: G = G::from_u64(85); + let __v_5: G = G::from_u64(46); + let __v_6: G = G::from_u64(104); + let __v_7: G = G::from_u64(31); + let __v_8: G = G::from_u64(76); + let __v_9: G = G::from_u64(206); + let __v_10: G = G::from_u64(255); + let __v_11: G = G::from_u64(127); + let __v_12: G = G::from_u64(120); + let __v_13: G = G::from_u64(59); + let __v_14: G = G::from_u64(90); + let __v_15: G = G::from_u64(100); + let __v_16: G = G::from_u64(224); + let __v_17: G = G::from_u64(2); + let __v_18: G = G::from_u64(87); + let __v_19: G = G::from_u64(94); + let __v_20: G = G::from_u64(220); + let __v_21: G = G::from_u64(177); + let __v_22: G = G::from_u64(192); + let __v_23: G = G::from_u64(79); + let __v_24: G = G::from_u64(160); + let __v_25: G = G::from_u64(197); + let __v_26: G = G::from_u64(102); + let __v_27: G = G::from_u64(44); + let __v_28: G = G::from_u64(226); + let __v_29: G = G::from_u64(221); + let __v_30: G = G::from_u64(52); + let __v_31: G = G::from_u64(56); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_280] = [__v_32]; + record.function_queries[280].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_281: usize = 0; +const IN_281: usize = 0; +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_281], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(158); + let __v_1: G = G::from_u64(134); + let __v_2: G = G::from_u64(255); + let __v_3: G = G::from_u64(67); + let __v_4: G = G::from_u64(177); + let __v_5: G = G::from_u64(90); + let __v_6: G = G::from_u64(235); + let __v_7: G = G::from_u64(175); + let __v_8: G = G::from_u64(179); + let __v_9: G = G::from_u64(223); + let __v_10: G = G::from_u64(97); + let __v_11: G = G::from_u64(10); + let __v_12: G = G::from_u64(150); + let __v_13: G = G::from_u64(221); + let __v_14: G = G::from_u64(68); + let __v_15: G = G::from_u64(146); + let __v_16: G = G::from_u64(255); + let __v_17: G = G::from_u64(156); + let __v_18: G = G::from_u64(216); + let __v_19: G = G::from_u64(170); + let __v_20: G = G::from_u64(184); + let __v_21: G = G::from_u64(122); + let __v_22: G = G::from_u64(130); + let __v_23: G = G::from_u64(2); + let __v_24: G = G::from_u64(91); + let __v_25: G = G::from_u64(97); + let __v_26: G = G::from_u64(124); + let __v_27: G = G::from_u64(154); + let __v_28: G = G::from_u64(11); + let __v_29: G = G::from_u64(191); + let __v_30: G = G::from_u64(98); + let __v_31: G = G::from_u64(128); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_281] = [__v_32]; + record.function_queries[281].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_282: usize = 0; +const IN_282: usize = 0; +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_282], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(155); + let __v_1: G = G::from_u64(193); + let __v_2: G = G::from_u64(53); + let __v_3: G = G::from_u64(57); + let __v_4: G = G::from_u64(182); + let __v_5: G = G::from_u64(139); + let __v_6: G = G::from_u64(14); + let __v_7: G = G::from_u64(28); + let __v_8: G = G::from_u64(90); + let __v_9: G = G::from_u64(83); + let __v_10: G = G::from_u64(129); + let __v_11: G = G::from_u64(133); + let __v_12: G = G::from_u64(128); + let __v_13: G = G::from_u64(170); + let __v_14: G = G::from_u64(9); + let __v_15: G = G::from_u64(106); + let __v_16: G = G::from_u64(101); + let __v_17: G = G::from_u64(144); + let __v_18: G = G::from_u64(127); + let __v_19: G = G::from_u64(99); + let __v_20: G = G::from_u64(175); + let __v_21: G = G::from_u64(69); + let __v_22: G = G::from_u64(136); + let __v_23: G = G::from_u64(161); + let __v_24: G = G::from_u64(233); + let __v_25: G = G::from_u64(30); + let __v_26: G = G::from_u64(20); + let __v_27: G = G::from_u64(211); + let __v_28: G = G::from_u64(77); + let __v_29: G = G::from_u64(158); + let __v_30: G = G::from_u64(77); + let __v_31: G = G::from_u64(134); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_282] = [__v_32]; + record.function_queries[282].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_283: usize = 0; +const IN_283: usize = 0; +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_283], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(181); + let __v_1: G = G::from_u64(44); + let __v_2: G = G::from_u64(77); + let __v_3: G = G::from_u64(13); + let __v_4: G = G::from_u64(56); + let __v_5: G = G::from_u64(120); + let __v_6: G = G::from_u64(242); + let __v_7: G = G::from_u64(135); + let __v_8: G = G::from_u64(113); + let __v_9: G = G::from_u64(159); + let __v_10: G = G::from_u64(101); + let __v_11: G = G::from_u64(208); + let __v_12: G = G::from_u64(8); + let __v_13: G = G::from_u64(138); + let __v_14: G = G::from_u64(38); + let __v_15: G = G::from_u64(154); + let __v_16: G = G::from_u64(240); + let __v_17: G = G::from_u64(246); + let __v_18: G = G::from_u64(229); + let __v_19: G = G::from_u64(177); + let __v_20: G = G::from_u64(183); + let __v_21: G = G::from_u64(239); + let __v_22: G = G::from_u64(86); + let __v_23: G = G::from_u64(41); + let __v_24: G = G::from_u64(131); + let __v_25: G = G::from_u64(9); + let __v_26: G = G::from_u64(99); + let __v_27: G = G::from_u64(220); + let __v_28: G = G::from_u64(183); + let __v_29: G = G::from_u64(94); + let __v_30: G = G::from_u64(108); + let __v_31: G = G::from_u64(238); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_283] = [__v_32]; + record.function_queries[283].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_284: usize = 0; +const IN_284: usize = 0; +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_284], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(116); + let __v_1: G = G::from_u64(54); + let __v_2: G = G::from_u64(217); + let __v_3: G = G::from_u64(250); + let __v_4: G = G::from_u64(124); + let __v_5: G = G::from_u64(206); + let __v_6: G = G::from_u64(62); + let __v_7: G = G::from_u64(249); + let __v_8: G = G::from_u64(27); + let __v_9: G = G::from_u64(201); + let __v_10: G = G::from_u64(144); + let __v_11: G = G::from_u64(60); + let __v_12: G = G::from_u64(197); + let __v_13: G = G::from_u64(170); + let __v_14: G = G::from_u64(50); + let __v_15: G = G::from_u64(212); + let __v_16: G = G::from_u64(19); + let __v_17: G = G::from_u64(218); + let __v_18: G = G::from_u64(47); + let __v_19: G = G::from_u64(108); + let __v_20: G = G::from_u64(167); + let __v_21: G = G::from_u64(194); + let __v_22: G = G::from_u64(26); + let __v_23: G = G::from_u64(146); + let __v_24: G = G::from_u64(53); + let __v_25: G = G::from_u64(180); + let __v_26: G = G::from_u64(26); + let __v_27: G = G::from_u64(47); + let __v_28: G = G::from_u64(196); + let __v_29: G = G::from_u64(130); + let __v_30: G = G::from_u64(223); + let __v_31: G = G::from_u64(252); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_284] = [__v_32]; + record.function_queries[284].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_285: usize = 0; +const IN_285: usize = 0; +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_285], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(110); + let __v_1: G = G::from_u64(161); + let __v_2: G = G::from_u64(164); + let __v_3: G = G::from_u64(79); + let __v_4: G = G::from_u64(115); + let __v_5: G = G::from_u64(120); + let __v_6: G = G::from_u64(227); + let __v_7: G = G::from_u64(114); + let __v_8: G = G::from_u64(254); + let __v_9: G = G::from_u64(181); + let __v_10: G = G::from_u64(143); + let __v_11: G = G::from_u64(181); + let __v_12: G = G::from_u64(44); + let __v_13: G = G::from_u64(128); + let __v_14: G = G::from_u64(132); + let __v_15: G = G::from_u64(98); + let __v_16: G = G::from_u64(96); + let __v_17: G = G::from_u64(87); + let __v_18: G = G::from_u64(179); + let __v_19: G = G::from_u64(243); + let __v_20: G = G::from_u64(135); + let __v_21: G = G::from_u64(73); + let __v_22: G = G::from_u64(94); + let __v_23: G = G::from_u64(118); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(185); + let __v_26: G = G::from_u64(113); + let __v_27: G = G::from_u64(163); + let __v_28: G = G::from_u64(139); + let __v_29: G = G::from_u64(36); + let __v_30: G = G::from_u64(66); + let __v_31: G = G::from_u64(118); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_285] = [__v_32]; + record.function_queries[285].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_286: usize = 0; +const IN_286: usize = 0; +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_286], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(208); + let __v_1: G = G::from_u64(145); + let __v_2: G = G::from_u64(149); + let __v_3: G = G::from_u64(112); + let __v_4: G = G::from_u64(248); + let __v_5: G = G::from_u64(147); + let __v_6: G = G::from_u64(45); + let __v_7: G = G::from_u64(223); + let __v_8: G = G::from_u64(93); + let __v_9: G = G::from_u64(255); + let __v_10: G = G::from_u64(67); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(171); + let __v_13: G = G::from_u64(118); + let __v_14: G = G::from_u64(103); + let __v_15: G = G::from_u64(209); + let __v_16: G = G::from_u64(186); + let __v_17: G = G::from_u64(171); + let __v_18: G = G::from_u64(147); + let __v_19: G = G::from_u64(36); + let __v_20: G = G::from_u64(219); + let __v_21: G = G::from_u64(193); + let __v_22: G = G::from_u64(54); + let __v_23: G = G::from_u64(172); + let __v_24: G = G::from_u64(156); + let __v_25: G = G::from_u64(129); + let __v_26: G = G::from_u64(41); + let __v_27: G = G::from_u64(46); + let __v_28: G = G::from_u64(209); + let __v_29: G = G::from_u64(200); + let __v_30: G = G::from_u64(31); + let __v_31: G = G::from_u64(233); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_286] = [__v_32]; + record.function_queries[286].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_287: usize = 0; +const IN_287: usize = 0; +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_287], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(68); + let __v_1: G = G::from_u64(81); + let __v_2: G = G::from_u64(67); + let __v_3: G = G::from_u64(32); + let __v_4: G = G::from_u64(189); + let __v_5: G = G::from_u64(147); + let __v_6: G = G::from_u64(53); + let __v_7: G = G::from_u64(160); + let __v_8: G = G::from_u64(137); + let __v_9: G = G::from_u64(66); + let __v_10: G = G::from_u64(231); + let __v_11: G = G::from_u64(125); + let __v_12: G = G::from_u64(232); + let __v_13: G = G::from_u64(7); + let __v_14: G = G::from_u64(126); + let __v_15: G = G::from_u64(56); + let __v_16: G = G::from_u64(63); + let __v_17: G = G::from_u64(17); + let __v_18: G = G::from_u64(160); + let __v_19: G = G::from_u64(246); + let __v_20: G = G::from_u64(21); + let __v_21: G = G::from_u64(12); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(12); + let __v_24: G = G::from_u64(152); + let __v_25: G = G::from_u64(35); + let __v_26: G = G::from_u64(200); + let __v_27: G = G::from_u64(116); + let __v_28: G = G::from_u64(103); + let __v_29: G = G::from_u64(88); + let __v_30: G = G::from_u64(153); + let __v_31: G = G::from_u64(101); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_287] = [__v_32]; + record.function_queries[287].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_288: usize = 0; +const IN_288: usize = 0; +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_288], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(24); + let __v_1: G = G::from_u64(76); + let __v_2: G = G::from_u64(166); + let __v_3: G = G::from_u64(169); + let __v_4: G = G::from_u64(50); + let __v_5: G = G::from_u64(164); + let __v_6: G = G::from_u64(197); + let __v_7: G = G::from_u64(253); + let __v_8: G = G::from_u64(10); + let __v_9: G = G::from_u64(44); + let __v_10: G = G::from_u64(22); + let __v_11: G = G::from_u64(149); + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(210); + let __v_14: G = G::from_u64(213); + let __v_15: G = G::from_u64(4); + let __v_16: G = G::from_u64(139); + let __v_17: G = G::from_u64(183); + let __v_18: G = G::from_u64(67); + let __v_19: G = G::from_u64(189); + let __v_20: G = G::from_u64(22); + let __v_21: G = G::from_u64(111); + let __v_22: G = G::from_u64(150); + let __v_23: G = G::from_u64(255); + let __v_24: G = G::from_u64(236); + let __v_25: G = G::from_u64(157); + let __v_26: G = G::from_u64(65); + let __v_27: G = G::from_u64(1); + let __v_28: G = G::from_u64(229); + let __v_29: G = G::from_u64(78); + let __v_30: G = G::from_u64(152); + let __v_31: G = G::from_u64(43); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_288] = [__v_32]; + record.function_queries[288].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_289: usize = 0; +const IN_289: usize = 0; +const OUT_289: usize = 1; +fn aiur_fn_289( + inp: [G; IN_289], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_289], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(22); + let __v_1: G = G::from_u64(58); + let __v_2: G = G::from_u64(140); + let __v_3: G = G::from_u64(40); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(202); + let __v_6: G = G::from_u64(81); + let __v_7: G = G::from_u64(218); + let __v_8: G = G::from_u64(175); + let __v_9: G = G::from_u64(254); + let __v_10: G = G::from_u64(27); + let __v_11: G = G::from_u64(113); + let __v_12: G = G::from_u64(87); + let __v_13: G = G::from_u64(81); + let __v_14: G = G::from_u64(39); + let __v_15: G = G::from_u64(148); + let __v_16: G = G::from_u64(42); + let __v_17: G = G::from_u64(5); + let __v_18: G = G::from_u64(48); + let __v_19: G = G::from_u64(4); + let __v_20: G = G::from_u64(64); + let __v_21: G = G::from_u64(82); + let __v_22: G = G::from_u64(75); + let __v_23: G = G::from_u64(20); + let __v_24: G = G::from_u64(92); + let __v_25: G = G::from_u64(143); + let __v_26: G = G::from_u64(205); + let __v_27: G = G::from_u64(204); + let __v_28: G = G::from_u64(94); + let __v_29: G = G::from_u64(224); + let __v_30: G = G::from_u64(8); + let __v_31: G = G::from_u64(182); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_289] = [__v_32]; + record.function_queries[289].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_290: usize = 0; +const IN_290: usize = 0; +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_290], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(22); + let __v_1: G = G::from_u64(189); + let __v_2: G = G::from_u64(16); + let __v_3: G = G::from_u64(54); + let __v_4: G = G::from_u64(94); + let __v_5: G = G::from_u64(230); + let __v_6: G = G::from_u64(250); + let __v_7: G = G::from_u64(64); + let __v_8: G = G::from_u64(180); + let __v_9: G = G::from_u64(161); + let __v_10: G = G::from_u64(221); + let __v_11: G = G::from_u64(192); + let __v_12: G = G::from_u64(221); + let __v_13: G = G::from_u64(38); + let __v_14: G = G::from_u64(200); + let __v_15: G = G::from_u64(164); + let __v_16: G = G::from_u64(157); + let __v_17: G = G::from_u64(184); + let __v_18: G = G::from_u64(248); + let __v_19: G = G::from_u64(177); + let __v_20: G = G::from_u64(235); + let __v_21: G = G::from_u64(86); + let __v_22: G = G::from_u64(178); + let __v_23: G = G::from_u64(172); + let __v_24: G = G::from_u64(42); + let __v_25: G = G::from_u64(23); + let __v_26: G = G::from_u64(158); + let __v_27: G = G::from_u64(162); + let __v_28: G = G::from_u64(68); + let __v_29: G = G::from_u64(5); + let __v_30: G = G::from_u64(152); + let __v_31: G = G::from_u64(215); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_290] = [__v_32]; + record.function_queries[290].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_291: usize = 0; +const IN_291: usize = 0; +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_291], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(111); + let __v_1: G = G::from_u64(226); + let __v_2: G = G::from_u64(30); + let __v_3: G = G::from_u64(53); + let __v_4: G = G::from_u64(169); + let __v_5: G = G::from_u64(163); + let __v_6: G = G::from_u64(8); + let __v_7: G = G::from_u64(222); + let __v_8: G = G::from_u64(175); + let __v_9: G = G::from_u64(229); + let __v_10: G = G::from_u64(50); + let __v_11: G = G::from_u64(16); + let __v_12: G = G::from_u64(219); + let __v_13: G = G::from_u64(91); + let __v_14: G = G::from_u64(40); + let __v_15: G = G::from_u64(86); + let __v_16: G = G::from_u64(193); + let __v_17: G = G::from_u64(133); + let __v_18: G = G::from_u64(220); + let __v_19: G = G::from_u64(20); + let __v_20: G = G::from_u64(126); + let __v_21: G = G::from_u64(242); + let __v_22: G = G::from_u64(113); + let __v_23: G = G::from_u64(124); + let __v_24: G = G::from_u64(14); + let __v_25: G = G::from_u64(115); + let __v_26: G = G::from_u64(160); + let __v_27: G = G::from_u64(250); + let __v_28: G = G::from_u64(58); + let __v_29: G = G::from_u64(211); + let __v_30: G = G::from_u64(22); + let __v_31: G = G::from_u64(144); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_291] = [__v_32]; + record.function_queries[291].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_292: usize = 0; +const IN_292: usize = 0; +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_292], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(73); + let __v_1: G = G::from_u64(161); + let __v_2: G = G::from_u64(103); + let __v_3: G = G::from_u64(20); + let __v_4: G = G::from_u64(189); + let __v_5: G = G::from_u64(123); + let __v_6: G = G::from_u64(130); + let __v_7: G = G::from_u64(3); + let __v_8: G = G::from_u64(124); + let __v_9: G = G::from_u64(216); + let __v_10: G = G::from_u64(231); + let __v_11: G = G::from_u64(118); + let __v_12: G = G::from_u64(51); + let __v_13: G = G::from_u64(29); + let __v_14: G = G::from_u64(130); + let __v_15: G = G::from_u64(98); + let __v_16: G = G::from_u64(130); + let __v_17: G = G::from_u64(155); + let __v_18: G = G::from_u64(199); + let __v_19: G = G::from_u64(12); + let __v_20: G = G::from_u64(142); + let __v_21: G = G::from_u64(227); + let __v_22: G = G::from_u64(99); + let __v_23: G = G::from_u64(200); + let __v_24: G = G::from_u64(102); + let __v_25: G = G::from_u64(199); + let __v_26: G = G::from_u64(6); + let __v_27: G = G::from_u64(11); + let __v_28: G = G::from_u64(243); + let __v_29: G = G::from_u64(102); + let __v_30: G = G::from_u64(205); + let __v_31: G = G::from_u64(155); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_292] = [__v_32]; + record.function_queries[292].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_293: usize = 0; +const IN_293: usize = 0; +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_293], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(245); + let __v_1: G = G::from_u64(187); + let __v_2: G = G::from_u64(36); + let __v_3: G = G::from_u64(87); + let __v_4: G = G::from_u64(103); + let __v_5: G = G::from_u64(253); + let __v_6: G = G::from_u64(188); + let __v_7: G = G::from_u64(104); + let __v_8: G = G::from_u64(59); + let __v_9: G = G::from_u64(238); + let __v_10: G = G::from_u64(158); + let __v_11: G = G::from_u64(28); + let __v_12: G = G::from_u64(168); + let __v_13: G = G::from_u64(217); + let __v_14: G = G::from_u64(167); + let __v_15: G = G::from_u64(36); + let __v_16: G = G::from_u64(116); + let __v_17: G = G::from_u64(38); + let __v_18: G = G::from_u64(251); + let __v_19: G = G::from_u64(36); + let __v_20: G = G::from_u64(198); + let __v_21: G = G::from_u64(123); + let __v_22: G = G::from_u64(44); + let __v_23: G = G::from_u64(63); + let __v_24: G = G::from_u64(34); + let __v_25: G = G::from_u64(125); + let __v_26: G = G::from_u64(229); + let __v_27: G = G::from_u64(27); + let __v_28: G = G::from_u64(95); + let __v_29: G = G::from_u64(131); + let __v_30: G = G::from_u64(155); + let __v_31: G = G::from_u64(38); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_293] = [__v_32]; + record.function_queries[293].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_294: usize = 0; +const IN_294: usize = 0; +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_294], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(66); + let __v_1: G = G::from_u64(38); + let __v_2: G = G::from_u64(88); + let __v_3: G = G::from_u64(208); + let __v_4: G = G::from_u64(67); + let __v_5: G = G::from_u64(238); + let __v_6: G = G::from_u64(72); + let __v_7: G = G::from_u64(47); + let __v_8: G = G::from_u64(113); + let __v_9: G = G::from_u64(2); + let __v_10: G = G::from_u64(210); + let __v_11: G = G::from_u64(246); + let __v_12: G = G::from_u64(234); + let __v_13: G = G::from_u64(101); + let __v_14: G = G::from_u64(150); + let __v_15: G = G::from_u64(102); + let __v_16: G = G::from_u64(72); + let __v_17: G = G::from_u64(8); + let __v_18: G = G::from_u64(232); + let __v_19: G = G::from_u64(153); + let __v_20: G = G::from_u64(171); + let __v_21: G = G::from_u64(173); + let __v_22: G = G::from_u64(98); + let __v_23: G = G::from_u64(128); + let __v_24: G = G::from_u64(128); + let __v_25: G = G::from_u64(71); + let __v_26: G = G::from_u64(138); + let __v_27: G = G::from_u64(30); + let __v_28: G = G::from_u64(145); + let __v_29: G = G::from_u64(137); + let __v_30: G = G::from_u64(240); + let __v_31: G = G::from_u64(170); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_294] = [__v_32]; + record.function_queries[294].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_295: usize = 0; +const IN_295: usize = 0; +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_295], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(204); + let __v_1: G = G::from_u64(108); + let __v_2: G = G::from_u64(220); + let __v_3: G = G::from_u64(115); + let __v_4: G = G::from_u64(224); + let __v_5: G = G::from_u64(223); + let __v_6: G = G::from_u64(64); + let __v_7: G = G::from_u64(75); + let __v_8: G = G::from_u64(167); + let __v_9: G = G::from_u64(104); + let __v_10: G = G::from_u64(92); + let __v_11: G = G::from_u64(115); + let __v_12: G = G::from_u64(62); + let __v_13: G = G::from_u64(187); + let __v_14: G = G::from_u64(231); + let __v_15: G = G::from_u64(193); + let __v_16: G = G::from_u64(174); + let __v_17: G = G::from_u64(204); + let __v_18: G = G::from_u64(110); + let __v_19: G = G::from_u64(244); + let __v_20: G = G::from_u64(101); + let __v_21: G = G::from_u64(3); + let __v_22: G = G::from_u64(209); + let __v_23: G = G::from_u64(10); + let __v_24: G = G::from_u64(173); + let __v_25: G = G::from_u64(88); + let __v_26: G = G::from_u64(191); + let __v_27: G = G::from_u64(112); + let __v_28: G = G::from_u64(248); + let __v_29: G = G::from_u64(74); + let __v_30: G = G::from_u64(72); + let __v_31: G = G::from_u64(88); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_295] = [__v_32]; + record.function_queries[295].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_296: usize = 0; +const IN_296: usize = 0; +const OUT_296: usize = 1; +fn aiur_fn_296( + inp: [G; IN_296], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_296], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(246); + let __v_1: G = G::from_u64(6); + let __v_2: G = G::from_u64(111); + let __v_3: G = G::from_u64(198); + let __v_4: G = G::from_u64(36); + let __v_5: G = G::from_u64(145); + let __v_6: G = G::from_u64(253); + let __v_7: G = G::from_u64(76); + let __v_8: G = G::from_u64(72); + let __v_9: G = G::from_u64(212); + let __v_10: G = G::from_u64(218); + let __v_11: G = G::from_u64(243); + let __v_12: G = G::from_u64(185); + let __v_13: G = G::from_u64(190); + let __v_14: G = G::from_u64(186); + let __v_15: G = G::from_u64(114); + let __v_16: G = G::from_u64(226); + let __v_17: G = G::from_u64(160); + let __v_18: G = G::from_u64(184); + let __v_19: G = G::from_u64(4); + let __v_20: G = G::from_u64(15); + let __v_21: G = G::from_u64(203); + let __v_22: G = G::from_u64(217); + let __v_23: G = G::from_u64(159); + let __v_24: G = G::from_u64(183); + let __v_25: G = G::from_u64(41); + let __v_26: G = G::from_u64(171); + let __v_27: G = G::from_u64(245); + let __v_28: G = G::from_u64(106); + let __v_29: G = G::from_u64(156); + let __v_30: G = G::from_u64(7); + let __v_31: G = G::from_u64(196); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_296] = [__v_32]; + record.function_queries[296].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_297: usize = 0; +const IN_297: usize = 0; +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_297], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(213); + let __v_1: G = G::from_u64(229); + let __v_2: G = G::from_u64(67); + let __v_3: G = G::from_u64(165); + let __v_4: G = G::from_u64(182); + let __v_5: G = G::from_u64(189); + let __v_6: G = G::from_u64(232); + let __v_7: G = G::from_u64(141); + let __v_8: G = G::from_u64(195); + let __v_9: G = G::from_u64(133); + let __v_10: G = G::from_u64(77); + let __v_11: G = G::from_u64(76); + let __v_12: G = G::from_u64(43); + let __v_13: G = G::from_u64(154); + let __v_14: G = G::from_u64(18); + let __v_15: G = G::from_u64(172); + let __v_16: G = G::from_u64(39); + let __v_17: G = G::from_u64(9); + let __v_18: G = G::from_u64(118); + let __v_19: G = G::from_u64(191); + let __v_20: G = G::from_u64(65); + let __v_21: G = G::from_u64(2); + let __v_22: G = G::from_u64(166); + let __v_23: G = G::from_u64(179); + let __v_24: G = G::from_u64(63); + let __v_25: G = G::from_u64(85); + let __v_26: G = G::from_u64(169); + let __v_27: G = G::from_u64(13); + let __v_28: G = G::from_u64(179); + let __v_29: G = G::from_u64(36); + let __v_30: G = G::from_u64(38); + let __v_31: G = G::from_u64(143); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_297] = [__v_32]; + record.function_queries[297].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_298: usize = 0; +const IN_298: usize = 0; +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_298], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(160); + let __v_1: G = G::from_u64(119); + let __v_2: G = G::from_u64(54); + let __v_3: G = G::from_u64(236); + let __v_4: G = G::from_u64(153); + let __v_5: G = G::from_u64(159); + let __v_6: G = G::from_u64(220); + let __v_7: G = G::from_u64(184); + let __v_8: G = G::from_u64(117); + let __v_9: G = G::from_u64(48); + let __v_10: G = G::from_u64(103); + let __v_11: G = G::from_u64(73); + let __v_12: G = G::from_u64(127); + let __v_13: G = G::from_u64(159); + let __v_14: G = G::from_u64(151); + let __v_15: G = G::from_u64(180); + let __v_16: G = G::from_u64(97); + let __v_17: G = G::from_u64(242); + let __v_18: G = G::from_u64(161); + let __v_19: G = G::from_u64(78); + let __v_20: G = G::from_u64(129); + let __v_21: G = G::from_u64(105); + let __v_22: G = G::from_u64(205); + let __v_23: G = G::from_u64(17); + let __v_24: G = G::from_u64(40); + let __v_25: G = G::from_u64(125); + let __v_26: G = G::from_u64(199); + let __v_27: G = G::from_u64(60); + let __v_28: G = G::from_u64(223); + let __v_29: G = G::from_u64(215); + let __v_30: G = G::from_u64(66); + let __v_31: G = G::from_u64(170); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_298] = [__v_32]; + record.function_queries[298].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_299: usize = 0; +const IN_299: usize = 0; +const OUT_299: usize = 1; +fn aiur_fn_299( + inp: [G; IN_299], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_299], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(192); + let __v_1: G = G::from_u64(127); + let __v_2: G = G::from_u64(21); + let __v_3: G = G::from_u64(137); + let __v_4: G = G::from_u64(189); + let __v_5: G = G::from_u64(125); + let __v_6: G = G::from_u64(204); + let __v_7: G = G::from_u64(85); + let __v_8: G = G::from_u64(110); + let __v_9: G = G::from_u64(56); + let __v_10: G = G::from_u64(78); + let __v_11: G = G::from_u64(66); + let __v_12: G = G::from_u64(186); + let __v_13: G = G::from_u64(177); + let __v_14: G = G::from_u64(66); + let __v_15: G = G::from_u64(168); + let __v_16: G = G::from_u64(79); + let __v_17: G = G::from_u64(122); + let __v_18: G = G::from_u64(98); + let __v_19: G = G::from_u64(85); + let __v_20: G = G::from_u64(211); + let __v_21: G = G::from_u64(155); + let __v_22: G = G::from_u64(89); + let __v_23: G = G::from_u64(176); + let __v_24: G = G::from_u64(249); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(25); + let __v_27: G = G::from_u64(128); + let __v_28: G = G::from_u64(71); + let __v_29: G = G::from_u64(37); + let __v_30: G = G::from_u64(34); + let __v_31: G = G::from_u64(150); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_299] = [__v_32]; + record.function_queries[299].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_300: usize = 0; +const IN_300: usize = 0; +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_300], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(40); + let __v_1: G = G::from_u64(220); + let __v_2: G = G::from_u64(27); + let __v_3: G = G::from_u64(61); + let __v_4: G = G::from_u64(61); + let __v_5: G = G::from_u64(46); + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(21); + let __v_8: G = G::from_u64(41); + let __v_9: G = G::from_u64(199); + let __v_10: G = G::from_u64(28); + let __v_11: G = G::from_u64(157); + let __v_12: G = G::from_u64(68); + let __v_13: G = G::from_u64(24); + let __v_14: G = G::from_u64(36); + let __v_15: G = G::from_u64(143); + let __v_16: G = G::from_u64(96); + let __v_17: G = G::from_u64(96); + let __v_18: G = G::from_u64(219); + let __v_19: G = G::from_u64(251); + let __v_20: G = G::from_u64(28); + let __v_21: G = G::from_u64(126); + let __v_22: G = G::from_u64(151); + let __v_23: G = G::from_u64(219); + let __v_24: G = G::from_u64(28); + let __v_25: G = G::from_u64(87); + let __v_26: G = G::from_u64(42); + let __v_27: G = G::from_u64(86); + let __v_28: G = G::from_u64(87); + let __v_29: G = G::from_u64(135); + let __v_30: G = G::from_u64(239); + let __v_31: G = G::from_u64(97); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_300] = [__v_32]; + record.function_queries[300].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_301: usize = 0; +const IN_301: usize = 0; +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_301], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(47); + let __v_1: G = G::from_u64(150); + let __v_2: G = G::from_u64(184); + let __v_3: G = G::from_u64(218); + let __v_4: G = G::from_u64(41); + let __v_5: G = G::from_u64(163); + let __v_6: G = G::from_u64(139); + let __v_7: G = G::from_u64(23); + let __v_8: G = G::from_u64(127); + let __v_9: G = G::from_u64(195); + let __v_10: G = G::from_u64(37); + let __v_11: G = G::from_u64(83); + let __v_12: G = G::from_u64(213); + let __v_13: G = G::from_u64(56); + let __v_14: G = G::from_u64(213); + let __v_15: G = G::from_u64(212); + let __v_16: G = G::from_u64(80); + let __v_17: G = G::from_u64(33); + let __v_18: G = G::from_u64(47); + let __v_19: G = G::from_u64(211); + let __v_20: G = G::from_u64(230); + let __v_21: G = G::from_u64(254); + let __v_22: G = G::from_u64(217); + let __v_23: G = G::from_u64(93); + let __v_24: G = G::from_u64(97); + let __v_25: G = G::from_u64(200); + let __v_26: G = G::from_u64(23); + let __v_27: G = G::from_u64(131); + let __v_28: G = G::from_u64(125); + let __v_29: G = G::from_u64(41); + let __v_30: G = G::from_u64(163); + let __v_31: G = G::from_u64(79); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_301] = [__v_32]; + record.function_queries[301].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_302: usize = 0; +const IN_302: usize = 0; +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 = G::from_u64(64); + let __v_1: G = G::from_u64(93); + let __v_2: G = G::from_u64(54); + let __v_3: G = G::from_u64(245); + let __v_4: G = G::from_u64(246); + let __v_5: G = G::from_u64(71); + let __v_6: G = G::from_u64(156); + let __v_7: G = G::from_u64(64); + let __v_8: G = G::from_u64(33); + let __v_9: G = G::from_u64(111); + let __v_10: G = G::from_u64(247); + let __v_11: G = G::from_u64(187); + let __v_12: G = G::from_u64(186); + let __v_13: G = G::from_u64(16); + let __v_14: G = G::from_u64(176); + let __v_15: G = G::from_u64(119); + let __v_16: G = G::from_u64(132); + let __v_17: G = G::from_u64(142); + let __v_18: G = G::from_u64(195); + let __v_19: G = G::from_u64(58); + let __v_20: G = G::from_u64(240); + let __v_21: G = G::from_u64(62); + let __v_22: G = G::from_u64(244); + let __v_23: G = G::from_u64(4); + let __v_24: G = G::from_u64(11); + let __v_25: G = G::from_u64(250); + let __v_26: G = G::from_u64(79); + let __v_27: G = G::from_u64(130); + let __v_28: G = G::from_u64(147); + let __v_29: G = G::from_u64(13); + let __v_30: G = G::from_u64(228); + let __v_31: G = G::from_u64(186); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_302] = [__v_32]; + record.function_queries[302].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_303: usize = 0; +const IN_303: usize = 0; +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 = G::from_u64(14); + let __v_1: G = G::from_u64(190); + let __v_2: G = G::from_u64(52); + let __v_3: G = G::from_u64(93); + let __v_4: G = G::from_u64(196); + let __v_5: G = G::from_u64(105); + let __v_6: G = G::from_u64(23); + let __v_7: G = G::from_u64(200); + let __v_8: G = G::from_u64(36); + let __v_9: G = G::from_u64(182); + let __v_10: G = G::from_u64(195); + let __v_11: G = G::from_u64(246); + let __v_12: G = G::from_u64(196); + let __v_13: G = G::from_u64(43); + let __v_14: G = G::from_u64(16); + let __v_15: G = G::from_u64(31); + let __v_16: G = G::from_u64(42); + let __v_17: G = G::from_u64(200); + let __v_18: G = G::from_u64(192); + let __v_19: G = G::from_u64(226); + let __v_20: G = G::from_u64(201); + let __v_21: G = G::from_u64(159); + let __v_22: G = G::from_u64(3); + let __v_23: G = G::from_u64(58); + let __v_24: G = G::from_u64(14); + let __v_25: G = G::from_u64(227); + let __v_26: G = G::from_u64(198); + let __v_27: G = G::from_u64(10); + let __v_28: G = G::from_u64(203); + let __v_29: G = G::from_u64(156); + let __v_30: G = G::from_u64(216); + let __v_31: G = G::from_u64(77); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_303] = [__v_32]; + record.function_queries[303].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_304: usize = 0; +const IN_304: usize = 0; +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_304], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(247); + let __v_1: G = G::from_u64(152); + let __v_2: G = G::from_u64(66); + let __v_3: G = G::from_u64(241); + let __v_4: G = G::from_u64(2); + let __v_5: G = G::from_u64(6); + let __v_6: G = G::from_u64(89); + let __v_7: G = G::from_u64(137); + let __v_8: G = G::from_u64(41); + let __v_9: G = G::from_u64(230); + let __v_10: G = G::from_u64(186); + let __v_11: G = G::from_u64(96); + let __v_12: G = G::from_u64(206); + let __v_13: G = G::from_u64(62); + let __v_14: G = G::from_u64(186); + let __v_15: G = G::from_u64(160); + let __v_16: G = G::from_u64(13); + let __v_17: G = G::from_u64(17); + let __v_18: G = G::from_u64(242); + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(201); + let __v_21: G = G::from_u64(158); + let __v_22: G = G::from_u64(128); + let __v_23: G = G::from_u64(40); + let __v_24: G = G::from_u64(95); + let __v_25: G = G::from_u64(70); + let __v_26: G = G::from_u64(204); + let __v_27: G = G::from_u64(14); + let __v_28: G = G::from_u64(144); + let __v_29: G = G::from_u64(147); + let __v_30: G = G::from_u64(40); + let __v_31: G = G::from_u64(50); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_304] = [__v_32]; + record.function_queries[304].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_305: usize = 0; +const IN_305: usize = 0; +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 = G::from_u64(66); + let __v_1: G = G::from_u64(13); + let __v_2: G = G::from_u64(234); + let __v_3: G = G::from_u64(210); + let __v_4: G = G::from_u64(22); + let __v_5: G = G::from_u64(138); + let __v_6: G = G::from_u64(189); + let __v_7: G = G::from_u64(22); + let __v_8: G = G::from_u64(167); + let __v_9: G = G::from_u64(5); + let __v_10: G = G::from_u64(14); + let __v_11: G = G::from_u64(223); + let __v_12: G = G::from_u64(216); + let __v_13: G = G::from_u64(225); + let __v_14: G = G::from_u64(125); + let __v_15: G = G::from_u64(69); + let __v_16: G = G::from_u64(21); + let __v_17: G = G::from_u64(82); + let __v_18: G = G::from_u64(55); + let __v_19: G = G::from_u64(211); + let __v_20: G = G::from_u64(17); + let __v_21: G = G::from_u64(135); + let __v_22: G = G::from_u64(130); + let __v_23: G = G::from_u64(208); + let __v_24: G = G::from_u64(230); + let __v_25: G = G::from_u64(139); + let __v_26: G = G::from_u64(109); + let __v_27: G = G::from_u64(232); + let __v_28: G = G::from_u64(119); + let __v_29: G = G::from_u64(66); + let __v_30: G = G::from_u64(203); + let __v_31: G = G::from_u64(141); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_305] = [__v_32]; + record.function_queries[305].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_306: usize = 0; +const IN_306: usize = 0; +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 = G::from_u64(193); + let __v_1: G = G::from_u64(39); + let __v_2: G = G::from_u64(248); + let __v_3: G = G::from_u64(159); + let __v_4: G = G::from_u64(146); + let __v_5: G = G::from_u64(224); + let __v_6: G = G::from_u64(72); + let __v_7: G = G::from_u64(31); + let __v_8: G = G::from_u64(122); + let __v_9: G = G::from_u64(62); + let __v_10: G = G::from_u64(6); + let __v_11: G = G::from_u64(49); + let __v_12: G = G::from_u64(197); + let __v_13: G = G::from_u64(97); + let __v_14: G = G::from_u64(95); + let __v_15: G = G::from_u64(231); + let __v_16: G = G::from_u64(246); + let __v_17: G = G::from_u64(203); + let __v_18: G = G::from_u64(191); + let __v_19: G = G::from_u64(67); + let __v_20: G = G::from_u64(157); + let __v_21: G = G::from_u64(95); + let __v_22: G = G::from_u64(215); + let __v_23: G = G::from_u64(235); + let __v_24: G = G::from_u64(164); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(251); + let __v_27: G = G::from_u64(6); + let __v_28: G = G::from_u64(3); + let __v_29: G = G::from_u64(174); + let __v_30: G = G::from_u64(223); + let __v_31: G = G::from_u64(47); + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_32]; + record.function_queries[306].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_307: usize = 1; +const IN_307: usize = 1; +const OUT_307: usize = 1; +fn aiur_fn_307( + inp: [G; IN_307], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_307], 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(1); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = { let __values: [G; 10] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_22]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_307] = [__v_23]; + record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__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[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = __r_arr[3]; + let __v_23: G = __r_arr[4]; + let __v_24: G = __r_arr[5]; + let __v_25: G = __r_arr[6]; + let __v_26: G = __r_arr[7]; + let __v_27: G = __r_arr[8]; + match __v_27.as_canonical_u64() { + 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_307] = [__v_29]; + record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_28: G = G::from_u64(0); + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_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_307] = [__v_30]; + record.function_queries[307].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +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_308], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + match __v_3.as_canonical_u64() { + 1u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_308] = [__v_1]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_308] = [__v_13]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + match __v_13.as_canonical_u64() { + 1u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_308] = [__v_0]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_308] = [__v_23]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__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[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = __r_arr[2]; + let __v_26: G = __r_arr[3]; + let __v_27: G = __r_arr[4]; + let __v_28: G = __r_arr[5]; + let __v_29: G = __r_arr[6]; + let __v_30: G = __r_arr[7]; + let __v_31: G = __r_arr[8]; + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__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[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __v_41: G = __r_arr[2]; + let __v_42: G = __r_arr[3]; + let __v_43: G = __r_arr[4]; + let __v_44: G = __r_arr[5]; + let __v_45: G = __r_arr[6]; + let __v_46: G = __r_arr[7]; + let __v_47: G = __r_arr[8]; + let __v_48: G = (__v_31 + __v_47); + let __v_49: G = G::from_u64(0); + let __r_arr: [G; OUT_308] = { let __args: [G; IN_308] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[308].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_308] = unsafe { *(result.output.as_ptr() as *const [G; OUT_308]) }; __ret } else { aiur_fn_308(__args, record, io_buffer, __cu)? } }; + let __v_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_308] = [__v_51]; + record.function_queries[308].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +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_309], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + 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 !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_309] = [__v_3]; + record.function_queries[309].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_310: usize = 16; +const IN_310: usize = 16; +const OUT_310: usize = 9; +fn aiur_fn_310( + inp: [G; IN_310], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_310], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_0, &__v_8) } else { bytes2_sub_value(__v_0, __v_8, record) }; + let __v_16: G = __b2_sub.0; + let __v_17: G = __b2_sub.1; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_1, &__v_9) } else { bytes2_sub_value(__v_1, __v_9, record) }; + let __v_18: G = __b2_sub.0; + let __v_19: G = __b2_sub.1; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_18, &__v_17) } else { bytes2_sub_value(__v_18, __v_17, record) }; + let __v_20: G = __b2_sub.0; + let __v_21: G = __b2_sub.1; + let __v_22: G = (__v_19 + __v_21); + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_2, &__v_10) } else { bytes2_sub_value(__v_2, __v_10, record) }; + let __v_23: G = __b2_sub.0; + let __v_24: G = __b2_sub.1; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_23, &__v_22) } else { bytes2_sub_value(__v_23, __v_22, record) }; + let __v_25: G = __b2_sub.0; + let __v_26: G = __b2_sub.1; + let __v_27: G = (__v_24 + __v_26); + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_3, &__v_11) } else { bytes2_sub_value(__v_3, __v_11, record) }; + let __v_28: G = __b2_sub.0; + let __v_29: G = __b2_sub.1; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_28, &__v_27) } else { bytes2_sub_value(__v_28, __v_27, record) }; + let __v_30: G = __b2_sub.0; + let __v_31: G = __b2_sub.1; + let __v_32: G = (__v_29 + __v_31); + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_4, &__v_12) } else { bytes2_sub_value(__v_4, __v_12, record) }; + let __v_33: G = __b2_sub.0; + let __v_34: G = __b2_sub.1; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_33, &__v_32) } else { bytes2_sub_value(__v_33, __v_32, record) }; + let __v_35: G = __b2_sub.0; + let __v_36: G = __b2_sub.1; + let __v_37: G = (__v_34 + __v_36); + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_5, &__v_13) } else { bytes2_sub_value(__v_5, __v_13, record) }; + let __v_38: G = __b2_sub.0; + let __v_39: G = __b2_sub.1; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_38, &__v_37) } else { bytes2_sub_value(__v_38, __v_37, record) }; + let __v_40: G = __b2_sub.0; + let __v_41: G = __b2_sub.1; + let __v_42: G = (__v_39 + __v_41); + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_6, &__v_14) } else { bytes2_sub_value(__v_6, __v_14, record) }; + let __v_43: G = __b2_sub.0; + let __v_44: G = __b2_sub.1; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_43, &__v_42) } else { bytes2_sub_value(__v_43, __v_42, record) }; + let __v_45: G = __b2_sub.0; + let __v_46: G = __b2_sub.1; + let __v_47: G = (__v_44 + __v_46); + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_7, &__v_15) } else { bytes2_sub_value(__v_7, __v_15, record) }; + let __v_48: G = __b2_sub.0; + let __v_49: G = __b2_sub.1; + let __b2_sub: (G, G) = if unconstrained { Bytes2::sub(&__v_48, &__v_47) } else { bytes2_sub_value(__v_48, __v_47, record) }; + let __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_310] = [__v_16, __v_20, __v_25, __v_30, __v_35, __v_40, __v_45, __v_50, __v_52]; + record.function_queries[310].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_311: usize = 3; +const IN_311: usize = 3; +const OUT_311: usize = 2; +fn aiur_fn_311( + inp: [G; IN_311], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_311], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + match __v_13.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_311] = [__v_25, __v_2]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(1); + let __v_25: G = { let __values: [G; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = G::from_u64(1); + let __ret: [G; OUT_311] = [__v_25, __v_26]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + match __v_13.as_canonical_u64() { + 1u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_311] = [__v_0, __v_23]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__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[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __v_34: G = __r_arr[3]; + let __v_35: G = __r_arr[4]; + let __v_36: G = __r_arr[5]; + let __v_37: G = __r_arr[6]; + let __v_38: G = __r_arr[7]; + let __v_39: G = __r_arr[8]; + let __v_40: G = G::from_u64(1); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 10] = [__v_40, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41, __v_41]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_12, __v_42, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __v_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_311] = [__v_46, __v_44]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__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[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = __r_arr[2]; + let __v_26: G = __r_arr[3]; + let __v_27: G = __r_arr[4]; + let __v_28: G = __r_arr[5]; + let __v_29: G = __r_arr[6]; + let __v_30: G = __r_arr[7]; + let __v_31: G = __r_arr[8]; + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __r_arr: [G; OUT_310] = { let __args: [G; IN_310] = [__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[310].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_310] = unsafe { *(result.output.as_ptr() as *const [G; OUT_310]) }; __ret } else { aiur_fn_310(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __v_41: G = __r_arr[2]; + let __v_42: G = __r_arr[3]; + let __v_43: G = __r_arr[4]; + let __v_44: G = __r_arr[5]; + let __v_45: G = __r_arr[6]; + let __v_46: G = __r_arr[7]; + let __v_47: G = __r_arr[8]; + let __v_48: G = (__v_31 + __v_47); + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_12, __v_22, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __v_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_311] = [__v_52, __v_50]; + record.function_queries[311].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_312: usize = 1; +const IN_312: usize = 1; +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_312], 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_312] = [__v_13]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_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]; + 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]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __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_312] = [__v_25]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(1); + let __v_25: G = G::from_u64(1); + let __v_26: G = { let __values: [G; 10] = [__v_24, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_312] = [__v_27]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + 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_312] = [__v_23]; + record.function_queries[312].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +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_313], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + let __r_arr: [G; OUT_311] = { let __args: [G; IN_311] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[311].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_311] = unsafe { *(result.output.as_ptr() as *const [G; OUT_311]) }; __ret } else { aiur_fn_311(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 10] = [__v_5, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_313] = [__v_7]; + record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_313] = [__v_5]; + record.function_queries[313].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +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_314], 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, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(1); + let __ret: [G; OUT_314] = [__v_13]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_314] = [__v_13]; + record.function_queries[314].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_315: usize = 1; +const IN_315: usize = 1; +const OUT_315: usize = 1; +fn aiur_fn_315( + inp: [G; IN_315], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_315], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(0); + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = { let __values: [G; 10] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_315] = [__v_14]; + record.function_queries[315].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_316: usize = 2; +const IN_316: usize = 2; +const OUT_316: usize = 2; +fn aiur_fn_316( + inp: [G; IN_316], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_316], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(256); + let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_3.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_316] = [__v_0, __v_1]; + record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_4: G = G::from_u64(256); + let __v_5: G = (__v_0 - __v_4); + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 + __v_6); + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __ret: [G; OUT_316] = [__v_8, __v_9]; + record.function_queries[316].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_317: usize = 1; +const IN_317: usize = 1; +const OUT_317: usize = 3; +fn aiur_fn_317( + inp: [G; IN_317], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_317], 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_316] = { let __args: [G; IN_316] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_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_316] = { let __args: [G; IN_316] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __ret: [G; OUT_317] = [__v_2, __v_5, __v_6]; + record.function_queries[317].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_318: usize = 16; +const IN_318: usize = 16; +const OUT_318: usize = 16; +fn aiur_fn_318( + inp: [G; IN_318], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_318], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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 = (__v_0 * __v_8); + let __v_17: G = (__v_0 * __v_9); + let __v_18: G = (__v_1 * __v_8); + let __v_19: G = (__v_17 + __v_18); + let __v_20: G = (__v_0 * __v_10); + let __v_21: G = (__v_1 * __v_9); + let __v_22: G = (__v_2 * __v_8); + let __v_23: G = (__v_21 + __v_22); + let __v_24: G = (__v_20 + __v_23); + let __v_25: G = (__v_0 * __v_11); + let __v_26: G = (__v_1 * __v_10); + let __v_27: G = (__v_2 * __v_9); + let __v_28: G = (__v_3 * __v_8); + let __v_29: G = (__v_27 + __v_28); + let __v_30: G = (__v_26 + __v_29); + let __v_31: G = (__v_25 + __v_30); + let __v_32: G = (__v_0 * __v_12); + let __v_33: G = (__v_1 * __v_11); + let __v_34: G = (__v_2 * __v_10); + let __v_35: G = (__v_3 * __v_9); + let __v_36: G = (__v_4 * __v_8); + let __v_37: G = (__v_35 + __v_36); + let __v_38: G = (__v_34 + __v_37); + let __v_39: G = (__v_33 + __v_38); + let __v_40: G = (__v_32 + __v_39); + let __v_41: G = (__v_0 * __v_13); + let __v_42: G = (__v_1 * __v_12); + let __v_43: G = (__v_2 * __v_11); + let __v_44: G = (__v_3 * __v_10); + let __v_45: G = (__v_4 * __v_9); + let __v_46: G = (__v_5 * __v_8); + let __v_47: G = (__v_45 + __v_46); + let __v_48: G = (__v_44 + __v_47); + let __v_49: G = (__v_43 + __v_48); + let __v_50: G = (__v_42 + __v_49); + let __v_51: G = (__v_41 + __v_50); + let __v_52: G = (__v_0 * __v_14); + let __v_53: G = (__v_1 * __v_13); + let __v_54: G = (__v_2 * __v_12); + let __v_55: G = (__v_3 * __v_11); + let __v_56: G = (__v_4 * __v_10); + let __v_57: G = (__v_5 * __v_9); + let __v_58: G = (__v_6 * __v_8); + let __v_59: G = (__v_57 + __v_58); + let __v_60: G = (__v_56 + __v_59); + let __v_61: G = (__v_55 + __v_60); + let __v_62: G = (__v_54 + __v_61); + let __v_63: G = (__v_53 + __v_62); + let __v_64: G = (__v_52 + __v_63); + let __v_65: G = (__v_0 * __v_15); + let __v_66: G = (__v_1 * __v_14); + let __v_67: G = (__v_2 * __v_13); + let __v_68: G = (__v_3 * __v_12); + let __v_69: G = (__v_4 * __v_11); + let __v_70: G = (__v_5 * __v_10); + let __v_71: G = (__v_6 * __v_9); + let __v_72: G = (__v_7 * __v_8); + let __v_73: G = (__v_71 + __v_72); + let __v_74: G = (__v_70 + __v_73); + let __v_75: G = (__v_69 + __v_74); + let __v_76: G = (__v_68 + __v_75); + let __v_77: G = (__v_67 + __v_76); + let __v_78: G = (__v_66 + __v_77); + let __v_79: G = (__v_65 + __v_78); + let __v_80: G = (__v_1 * __v_15); + let __v_81: G = (__v_2 * __v_14); + let __v_82: G = (__v_3 * __v_13); + let __v_83: G = (__v_4 * __v_12); + let __v_84: G = (__v_5 * __v_11); + let __v_85: G = (__v_6 * __v_10); + let __v_86: G = (__v_7 * __v_9); + let __v_87: G = (__v_85 + __v_86); + let __v_88: G = (__v_84 + __v_87); + let __v_89: G = (__v_83 + __v_88); + let __v_90: G = (__v_82 + __v_89); + let __v_91: G = (__v_81 + __v_90); + let __v_92: G = (__v_80 + __v_91); + let __v_93: G = (__v_2 * __v_15); + let __v_94: G = (__v_3 * __v_14); + let __v_95: G = (__v_4 * __v_13); + let __v_96: G = (__v_5 * __v_12); + let __v_97: G = (__v_6 * __v_11); + let __v_98: G = (__v_7 * __v_10); + let __v_99: G = (__v_97 + __v_98); + let __v_100: G = (__v_96 + __v_99); + let __v_101: G = (__v_95 + __v_100); + let __v_102: G = (__v_94 + __v_101); + let __v_103: G = (__v_93 + __v_102); + let __v_104: G = (__v_3 * __v_15); + let __v_105: G = (__v_4 * __v_14); + let __v_106: G = (__v_5 * __v_13); + let __v_107: G = (__v_6 * __v_12); + let __v_108: G = (__v_7 * __v_11); + let __v_109: G = (__v_107 + __v_108); + let __v_110: G = (__v_106 + __v_109); + let __v_111: G = (__v_105 + __v_110); + let __v_112: G = (__v_104 + __v_111); + let __v_113: G = (__v_4 * __v_15); + let __v_114: G = (__v_5 * __v_14); + let __v_115: G = (__v_6 * __v_13); + let __v_116: G = (__v_7 * __v_12); + let __v_117: G = (__v_115 + __v_116); + let __v_118: G = (__v_114 + __v_117); + let __v_119: G = (__v_113 + __v_118); + let __v_120: G = (__v_5 * __v_15); + let __v_121: G = (__v_6 * __v_14); + let __v_122: G = (__v_7 * __v_13); + let __v_123: G = (__v_121 + __v_122); + let __v_124: G = (__v_120 + __v_123); + let __v_125: G = (__v_6 * __v_15); + 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_317] = { let __args: [G; IN_317] = [__v_16]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_129: G = __r_arr[0]; + let __v_130: G = __r_arr[1]; + let __v_131: G = __r_arr[2]; + let __v_132: G = G::from_u64(0); + let __v_133: G = if unconstrained { Bytes2::xor(&__v_129, &__v_132) } else { bytes2_xor_value(__v_129, __v_132, record) }; + let __v_134: G = G::from_u64(0); + let __v_135: G = if unconstrained { Bytes2::xor(&__v_130, &__v_134) } else { bytes2_xor_value(__v_130, __v_134, record) }; + let __v_136: G = G::from_u64(0); + let __v_137: G = if unconstrained { Bytes2::xor(&__v_131, &__v_136) } else { bytes2_xor_value(__v_131, __v_136, record) }; + let __v_138: G = G::from_u64(256); + let __v_139: G = (__v_138 * __v_135); + let __v_140: G = G::from_u64(65536); + let __v_141: G = (__v_140 * __v_137); + let __v_142: G = (__v_139 + __v_141); + let __v_143: G = (__v_133 + __v_142); + if (__v_16 != __v_143) { + return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_143.as_canonical_u64() }); + } + let __v_144: G = G::from_u64(256); + let __v_145: G = (__v_144 * __v_137); + let __v_146: G = (__v_135 + __v_145); + let __v_147: G = (__v_19 + __v_146); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_147]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_148: G = __r_arr[0]; + let __v_149: G = __r_arr[1]; + let __v_150: G = __r_arr[2]; + let __v_151: G = G::from_u64(0); + let __v_152: G = if unconstrained { Bytes2::xor(&__v_148, &__v_151) } else { bytes2_xor_value(__v_148, __v_151, record) }; + let __v_153: G = G::from_u64(0); + let __v_154: G = if unconstrained { Bytes2::xor(&__v_149, &__v_153) } else { bytes2_xor_value(__v_149, __v_153, record) }; + let __v_155: G = G::from_u64(0); + let __v_156: G = if unconstrained { Bytes2::xor(&__v_150, &__v_155) } else { bytes2_xor_value(__v_150, __v_155, record) }; + let __v_157: G = G::from_u64(256); + let __v_158: G = (__v_157 * __v_154); + let __v_159: G = G::from_u64(65536); + let __v_160: G = (__v_159 * __v_156); + let __v_161: G = (__v_158 + __v_160); + let __v_162: G = (__v_152 + __v_161); + if (__v_147 != __v_162) { + return Err(ExecError::AssertEqMismatch { lhs: __v_147.as_canonical_u64(), rhs: __v_162.as_canonical_u64() }); + } + let __v_163: G = G::from_u64(256); + let __v_164: G = (__v_163 * __v_156); + let __v_165: G = (__v_154 + __v_164); + let __v_166: G = (__v_24 + __v_165); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_166]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_167: G = __r_arr[0]; + let __v_168: G = __r_arr[1]; + let __v_169: G = __r_arr[2]; + let __v_170: G = G::from_u64(0); + let __v_171: G = if unconstrained { Bytes2::xor(&__v_167, &__v_170) } else { bytes2_xor_value(__v_167, __v_170, record) }; + let __v_172: G = G::from_u64(0); + let __v_173: G = if unconstrained { Bytes2::xor(&__v_168, &__v_172) } else { bytes2_xor_value(__v_168, __v_172, record) }; + let __v_174: G = G::from_u64(0); + let __v_175: G = if unconstrained { Bytes2::xor(&__v_169, &__v_174) } else { bytes2_xor_value(__v_169, __v_174, record) }; + let __v_176: G = G::from_u64(256); + let __v_177: G = (__v_176 * __v_173); + let __v_178: G = G::from_u64(65536); + let __v_179: G = (__v_178 * __v_175); + let __v_180: G = (__v_177 + __v_179); + let __v_181: G = (__v_171 + __v_180); + if (__v_166 != __v_181) { + return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_181.as_canonical_u64() }); + } + let __v_182: G = G::from_u64(256); + let __v_183: G = (__v_182 * __v_175); + let __v_184: G = (__v_173 + __v_183); + let __v_185: G = (__v_31 + __v_184); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_185]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_186: G = __r_arr[0]; + let __v_187: G = __r_arr[1]; + let __v_188: G = __r_arr[2]; + let __v_189: G = G::from_u64(0); + let __v_190: G = if unconstrained { Bytes2::xor(&__v_186, &__v_189) } else { bytes2_xor_value(__v_186, __v_189, record) }; + let __v_191: G = G::from_u64(0); + let __v_192: G = if unconstrained { Bytes2::xor(&__v_187, &__v_191) } else { bytes2_xor_value(__v_187, __v_191, record) }; + let __v_193: G = G::from_u64(0); + let __v_194: G = if unconstrained { Bytes2::xor(&__v_188, &__v_193) } else { bytes2_xor_value(__v_188, __v_193, record) }; + let __v_195: G = G::from_u64(256); + let __v_196: G = (__v_195 * __v_192); + let __v_197: G = G::from_u64(65536); + let __v_198: G = (__v_197 * __v_194); + let __v_199: G = (__v_196 + __v_198); + let __v_200: G = (__v_190 + __v_199); + if (__v_185 != __v_200) { + return Err(ExecError::AssertEqMismatch { lhs: __v_185.as_canonical_u64(), rhs: __v_200.as_canonical_u64() }); + } + let __v_201: G = G::from_u64(256); + let __v_202: G = (__v_201 * __v_194); + let __v_203: G = (__v_192 + __v_202); + let __v_204: G = (__v_40 + __v_203); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_204]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_205: G = __r_arr[0]; + let __v_206: G = __r_arr[1]; + let __v_207: G = __r_arr[2]; + let __v_208: G = G::from_u64(0); + let __v_209: G = if unconstrained { Bytes2::xor(&__v_205, &__v_208) } else { bytes2_xor_value(__v_205, __v_208, record) }; + let __v_210: G = G::from_u64(0); + let __v_211: G = if unconstrained { Bytes2::xor(&__v_206, &__v_210) } else { bytes2_xor_value(__v_206, __v_210, record) }; + let __v_212: G = G::from_u64(0); + let __v_213: G = if unconstrained { Bytes2::xor(&__v_207, &__v_212) } else { bytes2_xor_value(__v_207, __v_212, record) }; + let __v_214: G = G::from_u64(256); + let __v_215: G = (__v_214 * __v_211); + let __v_216: G = G::from_u64(65536); + let __v_217: G = (__v_216 * __v_213); + let __v_218: G = (__v_215 + __v_217); + let __v_219: G = (__v_209 + __v_218); + if (__v_204 != __v_219) { + return Err(ExecError::AssertEqMismatch { lhs: __v_204.as_canonical_u64(), rhs: __v_219.as_canonical_u64() }); + } + let __v_220: G = G::from_u64(256); + let __v_221: G = (__v_220 * __v_213); + let __v_222: G = (__v_211 + __v_221); + let __v_223: G = (__v_51 + __v_222); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_223]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_224: G = __r_arr[0]; + let __v_225: G = __r_arr[1]; + let __v_226: G = __r_arr[2]; + let __v_227: G = G::from_u64(0); + let __v_228: G = if unconstrained { Bytes2::xor(&__v_224, &__v_227) } else { bytes2_xor_value(__v_224, __v_227, record) }; + let __v_229: G = G::from_u64(0); + let __v_230: G = if unconstrained { Bytes2::xor(&__v_225, &__v_229) } else { bytes2_xor_value(__v_225, __v_229, record) }; + let __v_231: G = G::from_u64(0); + let __v_232: G = if unconstrained { Bytes2::xor(&__v_226, &__v_231) } else { bytes2_xor_value(__v_226, __v_231, record) }; + let __v_233: G = G::from_u64(256); + let __v_234: G = (__v_233 * __v_230); + let __v_235: G = G::from_u64(65536); + let __v_236: G = (__v_235 * __v_232); + let __v_237: G = (__v_234 + __v_236); + let __v_238: G = (__v_228 + __v_237); + if (__v_223 != __v_238) { + return Err(ExecError::AssertEqMismatch { lhs: __v_223.as_canonical_u64(), rhs: __v_238.as_canonical_u64() }); + } + let __v_239: G = G::from_u64(256); + let __v_240: G = (__v_239 * __v_232); + let __v_241: G = (__v_230 + __v_240); + let __v_242: G = (__v_64 + __v_241); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_242]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_243: G = __r_arr[0]; + let __v_244: G = __r_arr[1]; + let __v_245: G = __r_arr[2]; + let __v_246: G = G::from_u64(0); + let __v_247: G = if unconstrained { Bytes2::xor(&__v_243, &__v_246) } else { bytes2_xor_value(__v_243, __v_246, record) }; + let __v_248: G = G::from_u64(0); + let __v_249: G = if unconstrained { Bytes2::xor(&__v_244, &__v_248) } else { bytes2_xor_value(__v_244, __v_248, record) }; + let __v_250: G = G::from_u64(0); + let __v_251: G = if unconstrained { Bytes2::xor(&__v_245, &__v_250) } else { bytes2_xor_value(__v_245, __v_250, record) }; + let __v_252: G = G::from_u64(256); + let __v_253: G = (__v_252 * __v_249); + let __v_254: G = G::from_u64(65536); + let __v_255: G = (__v_254 * __v_251); + let __v_256: G = (__v_253 + __v_255); + let __v_257: G = (__v_247 + __v_256); + if (__v_242 != __v_257) { + return Err(ExecError::AssertEqMismatch { lhs: __v_242.as_canonical_u64(), rhs: __v_257.as_canonical_u64() }); + } + let __v_258: G = G::from_u64(256); + let __v_259: G = (__v_258 * __v_251); + let __v_260: G = (__v_249 + __v_259); + let __v_261: G = (__v_79 + __v_260); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_261]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_262: G = __r_arr[0]; + let __v_263: G = __r_arr[1]; + let __v_264: G = __r_arr[2]; + let __v_265: G = G::from_u64(0); + let __v_266: G = if unconstrained { Bytes2::xor(&__v_262, &__v_265) } else { bytes2_xor_value(__v_262, __v_265, record) }; + let __v_267: G = G::from_u64(0); + let __v_268: G = if unconstrained { Bytes2::xor(&__v_263, &__v_267) } else { bytes2_xor_value(__v_263, __v_267, record) }; + let __v_269: G = G::from_u64(0); + let __v_270: G = if unconstrained { Bytes2::xor(&__v_264, &__v_269) } else { bytes2_xor_value(__v_264, __v_269, record) }; + let __v_271: G = G::from_u64(256); + let __v_272: G = (__v_271 * __v_268); + let __v_273: G = G::from_u64(65536); + let __v_274: G = (__v_273 * __v_270); + let __v_275: G = (__v_272 + __v_274); + let __v_276: G = (__v_266 + __v_275); + if (__v_261 != __v_276) { + return Err(ExecError::AssertEqMismatch { lhs: __v_261.as_canonical_u64(), rhs: __v_276.as_canonical_u64() }); + } + let __v_277: G = G::from_u64(256); + let __v_278: G = (__v_277 * __v_270); + let __v_279: G = (__v_268 + __v_278); + let __v_280: G = (__v_92 + __v_279); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_280]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_281: G = __r_arr[0]; + let __v_282: G = __r_arr[1]; + let __v_283: G = __r_arr[2]; + let __v_284: G = G::from_u64(0); + let __v_285: G = if unconstrained { Bytes2::xor(&__v_281, &__v_284) } else { bytes2_xor_value(__v_281, __v_284, record) }; + let __v_286: G = G::from_u64(0); + let __v_287: G = if unconstrained { Bytes2::xor(&__v_282, &__v_286) } else { bytes2_xor_value(__v_282, __v_286, record) }; + let __v_288: G = G::from_u64(0); + let __v_289: G = if unconstrained { Bytes2::xor(&__v_283, &__v_288) } else { bytes2_xor_value(__v_283, __v_288, record) }; + let __v_290: G = G::from_u64(256); + let __v_291: G = (__v_290 * __v_287); + let __v_292: G = G::from_u64(65536); + let __v_293: G = (__v_292 * __v_289); + let __v_294: G = (__v_291 + __v_293); + let __v_295: G = (__v_285 + __v_294); + if (__v_280 != __v_295) { + return Err(ExecError::AssertEqMismatch { lhs: __v_280.as_canonical_u64(), rhs: __v_295.as_canonical_u64() }); + } + let __v_296: G = G::from_u64(256); + let __v_297: G = (__v_296 * __v_289); + let __v_298: G = (__v_287 + __v_297); + let __v_299: G = (__v_103 + __v_298); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_299]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_300: G = __r_arr[0]; + let __v_301: G = __r_arr[1]; + let __v_302: G = __r_arr[2]; + let __v_303: G = G::from_u64(0); + let __v_304: G = if unconstrained { Bytes2::xor(&__v_300, &__v_303) } else { bytes2_xor_value(__v_300, __v_303, record) }; + let __v_305: G = G::from_u64(0); + let __v_306: G = if unconstrained { Bytes2::xor(&__v_301, &__v_305) } else { bytes2_xor_value(__v_301, __v_305, record) }; + let __v_307: G = G::from_u64(0); + let __v_308: G = if unconstrained { Bytes2::xor(&__v_302, &__v_307) } else { bytes2_xor_value(__v_302, __v_307, record) }; + let __v_309: G = G::from_u64(256); + let __v_310: G = (__v_309 * __v_306); + let __v_311: G = G::from_u64(65536); + let __v_312: G = (__v_311 * __v_308); + let __v_313: G = (__v_310 + __v_312); + let __v_314: G = (__v_304 + __v_313); + if (__v_299 != __v_314) { + return Err(ExecError::AssertEqMismatch { lhs: __v_299.as_canonical_u64(), rhs: __v_314.as_canonical_u64() }); + } + let __v_315: G = G::from_u64(256); + let __v_316: G = (__v_315 * __v_308); + let __v_317: G = (__v_306 + __v_316); + let __v_318: G = (__v_112 + __v_317); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_318]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_319: G = __r_arr[0]; + let __v_320: G = __r_arr[1]; + let __v_321: G = __r_arr[2]; + let __v_322: G = G::from_u64(0); + let __v_323: G = if unconstrained { Bytes2::xor(&__v_319, &__v_322) } else { bytes2_xor_value(__v_319, __v_322, record) }; + let __v_324: G = G::from_u64(0); + let __v_325: G = if unconstrained { Bytes2::xor(&__v_320, &__v_324) } else { bytes2_xor_value(__v_320, __v_324, record) }; + let __v_326: G = G::from_u64(0); + let __v_327: G = if unconstrained { Bytes2::xor(&__v_321, &__v_326) } else { bytes2_xor_value(__v_321, __v_326, record) }; + let __v_328: G = G::from_u64(256); + let __v_329: G = (__v_328 * __v_325); + let __v_330: G = G::from_u64(65536); + let __v_331: G = (__v_330 * __v_327); + let __v_332: G = (__v_329 + __v_331); + let __v_333: G = (__v_323 + __v_332); + if (__v_318 != __v_333) { + return Err(ExecError::AssertEqMismatch { lhs: __v_318.as_canonical_u64(), rhs: __v_333.as_canonical_u64() }); + } + let __v_334: G = G::from_u64(256); + let __v_335: G = (__v_334 * __v_327); + let __v_336: G = (__v_325 + __v_335); + let __v_337: G = (__v_119 + __v_336); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_337]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_338: G = __r_arr[0]; + let __v_339: G = __r_arr[1]; + let __v_340: G = __r_arr[2]; + let __v_341: G = G::from_u64(0); + let __v_342: G = if unconstrained { Bytes2::xor(&__v_338, &__v_341) } else { bytes2_xor_value(__v_338, __v_341, record) }; + let __v_343: G = G::from_u64(0); + let __v_344: G = if unconstrained { Bytes2::xor(&__v_339, &__v_343) } else { bytes2_xor_value(__v_339, __v_343, record) }; + let __v_345: G = G::from_u64(0); + let __v_346: G = if unconstrained { Bytes2::xor(&__v_340, &__v_345) } else { bytes2_xor_value(__v_340, __v_345, record) }; + let __v_347: G = G::from_u64(256); + let __v_348: G = (__v_347 * __v_344); + let __v_349: G = G::from_u64(65536); + let __v_350: G = (__v_349 * __v_346); + let __v_351: G = (__v_348 + __v_350); + let __v_352: G = (__v_342 + __v_351); + if (__v_337 != __v_352) { + return Err(ExecError::AssertEqMismatch { lhs: __v_337.as_canonical_u64(), rhs: __v_352.as_canonical_u64() }); + } + let __v_353: G = G::from_u64(256); + let __v_354: G = (__v_353 * __v_346); + let __v_355: G = (__v_344 + __v_354); + let __v_356: G = (__v_124 + __v_355); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_356]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_357: G = __r_arr[0]; + let __v_358: G = __r_arr[1]; + let __v_359: G = __r_arr[2]; + let __v_360: G = G::from_u64(0); + let __v_361: G = if unconstrained { Bytes2::xor(&__v_357, &__v_360) } else { bytes2_xor_value(__v_357, __v_360, record) }; + let __v_362: G = G::from_u64(0); + let __v_363: G = if unconstrained { Bytes2::xor(&__v_358, &__v_362) } else { bytes2_xor_value(__v_358, __v_362, record) }; + let __v_364: G = G::from_u64(0); + let __v_365: G = if unconstrained { Bytes2::xor(&__v_359, &__v_364) } else { bytes2_xor_value(__v_359, __v_364, record) }; + let __v_366: G = G::from_u64(256); + let __v_367: G = (__v_366 * __v_363); + let __v_368: G = G::from_u64(65536); + let __v_369: G = (__v_368 * __v_365); + let __v_370: G = (__v_367 + __v_369); + let __v_371: G = (__v_361 + __v_370); + if (__v_356 != __v_371) { + return Err(ExecError::AssertEqMismatch { lhs: __v_356.as_canonical_u64(), rhs: __v_371.as_canonical_u64() }); + } + let __v_372: G = G::from_u64(256); + let __v_373: G = (__v_372 * __v_365); + let __v_374: G = (__v_363 + __v_373); + let __v_375: G = (__v_127 + __v_374); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_375]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_376: G = __r_arr[0]; + let __v_377: G = __r_arr[1]; + let __v_378: G = __r_arr[2]; + let __v_379: G = G::from_u64(0); + let __v_380: G = if unconstrained { Bytes2::xor(&__v_376, &__v_379) } else { bytes2_xor_value(__v_376, __v_379, record) }; + let __v_381: G = G::from_u64(0); + let __v_382: G = if unconstrained { Bytes2::xor(&__v_377, &__v_381) } else { bytes2_xor_value(__v_377, __v_381, record) }; + let __v_383: G = G::from_u64(0); + let __v_384: G = if unconstrained { Bytes2::xor(&__v_378, &__v_383) } else { bytes2_xor_value(__v_378, __v_383, record) }; + let __v_385: G = G::from_u64(256); + let __v_386: G = (__v_385 * __v_382); + let __v_387: G = G::from_u64(65536); + let __v_388: G = (__v_387 * __v_384); + let __v_389: G = (__v_386 + __v_388); + let __v_390: G = (__v_380 + __v_389); + if (__v_375 != __v_390) { + return Err(ExecError::AssertEqMismatch { lhs: __v_375.as_canonical_u64(), rhs: __v_390.as_canonical_u64() }); + } + let __v_391: G = G::from_u64(256); + let __v_392: G = (__v_391 * __v_384); + let __v_393: G = (__v_382 + __v_392); + let __v_394: G = (__v_128 + __v_393); + let __r_arr: [G; OUT_317] = { let __args: [G; IN_317] = [__v_394]; let __cu = true; if let Some(result) = record.function_queries[317].get_mut(&__args[..]) { 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_395: G = __r_arr[0]; + let __v_396: G = __r_arr[1]; + let __v_397: G = __r_arr[2]; + let __v_398: G = G::from_u64(0); + let __v_399: G = if unconstrained { Bytes2::xor(&__v_395, &__v_398) } else { bytes2_xor_value(__v_395, __v_398, record) }; + let __v_400: G = G::from_u64(0); + let __v_401: G = if unconstrained { Bytes2::xor(&__v_396, &__v_400) } else { bytes2_xor_value(__v_396, __v_400, record) }; + let __v_402: G = G::from_u64(0); + let __v_403: G = if unconstrained { Bytes2::xor(&__v_397, &__v_402) } else { bytes2_xor_value(__v_397, __v_402, record) }; + let __v_404: G = G::from_u64(256); + let __v_405: G = (__v_404 * __v_401); + let __v_406: G = G::from_u64(65536); + let __v_407: G = (__v_406 * __v_403); + let __v_408: G = (__v_405 + __v_407); + let __v_409: G = (__v_399 + __v_408); + if (__v_394 != __v_409) { + return Err(ExecError::AssertEqMismatch { lhs: __v_394.as_canonical_u64(), rhs: __v_409.as_canonical_u64() }); + } + let __v_410: G = G::from_u64(256); + let __v_411: G = (__v_410 * __v_403); + let __v_412: G = (__v_401 + __v_411); + let __ret: [G; OUT_318] = [__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_412]; + record.function_queries[318].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_319: usize = 2; +const IN_319: usize = 2; +const OUT_319: usize = 1; +fn aiur_fn_319( + inp: [G; IN_319], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_319], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 10] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_320] = { let __args: [G; IN_320] = [__v_0, __v_1, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_319] = [__v_6]; + record.function_queries[319].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_320: usize = 4; +const IN_320: usize = 4; +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_320], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 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_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]; + let __v_10: G = __loaded[6]; + let __v_11: G = __loaded[7]; + let __v_12: G = __loaded[8]; + let __v_13: G = __loaded[9]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_320] = [__v_2]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.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_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[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_322] = { let __args: [G; IN_322] = [__v_25, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_2, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_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_320] = { let __args: [G; IN_320] = [__v_13, __v_1, __v_27, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[320].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_320] = unsafe { *(result.output.as_ptr() as *const [G; OUT_320]) }; __ret } else { aiur_fn_320(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_320] = [__v_30]; + record.function_queries[320].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_321: usize = 18; +const IN_321: usize = 18; +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_321], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + match __v_18.as_canonical_u64() { + 1u64 => { + 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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __ret: [G; OUT_321] = [__v_17]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__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[737].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_321] = [__v_29]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __r_arr: [G; OUT_318] = { let __args: [G; IN_318] = [__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[318].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_318] = unsafe { *(result.output.as_ptr() as *const [G; OUT_318]) }; __ret } else { aiur_fn_318(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __v_37: G = __r_arr[9]; + let __v_38: G = __r_arr[10]; + let __v_39: G = __r_arr[11]; + let __v_40: G = __r_arr[12]; + let __v_41: G = __r_arr[13]; + let __v_42: G = __r_arr[14]; + let __v_43: G = __r_arr[15]; + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__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[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __v_47: G = __r_arr[3]; + let __v_48: G = __r_arr[4]; + let __v_49: G = __r_arr[5]; + let __v_50: G = __r_arr[6]; + let __v_51: G = __r_arr[7]; + let __v_52: G = __r_arr[8]; + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __r_arr: [G; OUT_7] = { let __args: [G; IN_7] = [__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[7].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_7] = unsafe { *(result.output.as_ptr() as *const [G; OUT_7]) }; __ret } else { aiur_fn_7(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __v_61: G = __r_arr[1]; + let __v_62: G = __r_arr[2]; + let __v_63: G = __r_arr[3]; + let __v_64: G = __r_arr[4]; + let __v_65: G = __r_arr[5]; + let __v_66: G = __r_arr[6]; + let __v_67: G = __r_arr[7]; + let __v_68: G = __r_arr[8]; + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__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[737].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __r_arr: [G; OUT_321] = { let __args: [G; IN_321] = [__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[321].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_321] = unsafe { *(result.output.as_ptr() as *const [G; OUT_321]) }; __ret } else { aiur_fn_321(__args, record, io_buffer, __cu)? } }; + let __v_70: G = __r_arr[0]; + let __ret: [G; OUT_321] = [__v_70]; + record.function_queries[321].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }) +} + +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_322], 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_322] = [__v_0]; + record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_0]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_322] = { let __args: [G; IN_322] = [__v_11, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[322].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_322] = unsafe { *(result.output.as_ptr() as *const [G; OUT_322]) }; __ret } else { aiur_fn_322(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_322] = [__v_14]; + record.function_queries[322].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_323: usize = 1; +const IN_323: usize = 1; +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_323], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_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]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_323] = [__v_12]; + record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_323] = [__v_12]; + record.function_queries[323].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_324: usize = 2; +const IN_324: usize = 2; +const OUT_324: usize = 2; +fn aiur_fn_324( + inp: [G; IN_324], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __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_319] = { let __args: [G; IN_319] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_4, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + if (__v_6 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64() }); + } + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_324] = [__v_2, __v_3]; + record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_9, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + if (__v_10 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + let __ret: [G; OUT_324] = [__v_2, __v_3]; + record.function_queries[324].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }) +} + +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_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_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __ret: [G; OUT_325] = [__v_2]; + record.function_queries[325].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_326], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __ret: [G; OUT_326] = [__v_3]; + record.function_queries[326].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +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_327], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_327] = [__v_0]; + record.function_queries[327].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 !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_3: G = __r_arr[0]; + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_327] = [__v_4]; + record.function_queries[327].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +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_328], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_328] = [__v_15]; + record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(2); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 10] = [__v_12, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = { let __values: [G; 10] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_14]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_324] = { let __args: [G; IN_324] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[324].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_324] = unsafe { *(result.output.as_ptr() as *const [G; OUT_324]) }; __ret } else { aiur_fn_324(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + match __v_22.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_328] = [__v_21]; + record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_328] = [__v_23]; + record.function_queries[328].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_329: usize = 16; +const IN_329: usize = 16; +const OUT_329: usize = 8; +fn aiur_fn_329( + inp: [G; IN_329], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_329], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = if unconstrained { Bytes2::and(&__v_0, &__v_8) } else { bytes2_and_value(__v_0, __v_8, record) }; + let __v_17: G = if unconstrained { Bytes2::and(&__v_1, &__v_9) } else { bytes2_and_value(__v_1, __v_9, record) }; + let __v_18: G = if unconstrained { Bytes2::and(&__v_2, &__v_10) } else { bytes2_and_value(__v_2, __v_10, record) }; + let __v_19: G = if unconstrained { Bytes2::and(&__v_3, &__v_11) } else { bytes2_and_value(__v_3, __v_11, record) }; + let __v_20: G = if unconstrained { Bytes2::and(&__v_4, &__v_12) } else { bytes2_and_value(__v_4, __v_12, record) }; + let __v_21: G = if unconstrained { Bytes2::and(&__v_5, &__v_13) } else { bytes2_and_value(__v_5, __v_13, record) }; + let __v_22: G = if unconstrained { Bytes2::and(&__v_6, &__v_14) } else { bytes2_and_value(__v_6, __v_14, record) }; + let __v_23: G = if unconstrained { Bytes2::and(&__v_7, &__v_15) } else { bytes2_and_value(__v_7, __v_15, record) }; + let __ret: [G; OUT_329] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + record.function_queries[329].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_330: usize = 16; +const IN_330: usize = 16; +const OUT_330: usize = 8; +fn aiur_fn_330( + inp: [G; IN_330], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_330], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = if unconstrained { Bytes2::or(&__v_0, &__v_8) } else { bytes2_or_value(__v_0, __v_8, record) }; + let __v_17: G = if unconstrained { Bytes2::or(&__v_1, &__v_9) } else { bytes2_or_value(__v_1, __v_9, record) }; + let __v_18: G = if unconstrained { Bytes2::or(&__v_2, &__v_10) } else { bytes2_or_value(__v_2, __v_10, record) }; + let __v_19: G = if unconstrained { Bytes2::or(&__v_3, &__v_11) } else { bytes2_or_value(__v_3, __v_11, record) }; + let __v_20: G = if unconstrained { Bytes2::or(&__v_4, &__v_12) } else { bytes2_or_value(__v_4, __v_12, record) }; + let __v_21: G = if unconstrained { Bytes2::or(&__v_5, &__v_13) } else { bytes2_or_value(__v_5, __v_13, record) }; + let __v_22: G = if unconstrained { Bytes2::or(&__v_6, &__v_14) } else { bytes2_or_value(__v_6, __v_14, record) }; + let __v_23: G = if unconstrained { Bytes2::or(&__v_7, &__v_15) } else { bytes2_or_value(__v_7, __v_15, record) }; + let __ret: [G; OUT_330] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + record.function_queries[330].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_331: usize = 16; +const IN_331: usize = 16; +const OUT_331: usize = 8; +fn aiur_fn_331( + inp: [G; IN_331], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = if unconstrained { Bytes2::xor(&__v_0, &__v_8) } else { bytes2_xor_value(__v_0, __v_8, record) }; + let __v_17: G = if unconstrained { Bytes2::xor(&__v_1, &__v_9) } else { bytes2_xor_value(__v_1, __v_9, record) }; + let __v_18: G = if unconstrained { Bytes2::xor(&__v_2, &__v_10) } else { bytes2_xor_value(__v_2, __v_10, record) }; + let __v_19: G = if unconstrained { Bytes2::xor(&__v_3, &__v_11) } else { bytes2_xor_value(__v_3, __v_11, record) }; + let __v_20: G = if unconstrained { Bytes2::xor(&__v_4, &__v_12) } else { bytes2_xor_value(__v_4, __v_12, record) }; + let __v_21: G = if unconstrained { Bytes2::xor(&__v_5, &__v_13) } else { bytes2_xor_value(__v_5, __v_13, record) }; + let __v_22: G = if unconstrained { Bytes2::xor(&__v_6, &__v_14) } else { bytes2_xor_value(__v_6, __v_14, record) }; + let __v_23: G = if unconstrained { Bytes2::xor(&__v_7, &__v_15) } else { bytes2_xor_value(__v_7, __v_15, record) }; + let __ret: [G; OUT_331] = [__v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23]; + record.function_queries[331].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_332: usize = 2; +const IN_332: usize = 2; +const OUT_332: usize = 1; +fn aiur_fn_332( + inp: [G; IN_332], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_332], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __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 __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_332] = [__v_14]; + record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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]; + 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]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_332] = [__v_24]; + record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_329] = { let __args: [G; IN_329] = [__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[329].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_329] = unsafe { *(result.output.as_ptr() as *const [G; OUT_329]) }; __ret } else { aiur_fn_329(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = __r_arr[2]; + let __v_26: G = __r_arr[3]; + let __v_27: G = __r_arr[4]; + let __v_28: G = __r_arr[5]; + let __v_29: G = __r_arr[6]; + let __v_30: G = __r_arr[7]; + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __v_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_332] = [__v_32]; + record.function_queries[332].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +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_333], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 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_333] = [__v_1]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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]; + 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]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_333] = [__v_0]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_330] = { let __args: [G; IN_330] = [__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[330].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_330] = unsafe { *(result.output.as_ptr() as *const [G; OUT_330]) }; __ret } else { aiur_fn_330(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = __r_arr[2]; + let __v_26: G = __r_arr[3]; + let __v_27: G = __r_arr[4]; + let __v_28: G = __r_arr[5]; + let __v_29: G = __r_arr[6]; + let __v_30: G = __r_arr[7]; + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __v_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_333] = [__v_32]; + record.function_queries[333].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +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_334], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 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_334] = [__v_1]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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]; + 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]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_334] = [__v_0]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_331] = { let __args: [G; IN_331] = [__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[331].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_331] = unsafe { *(result.output.as_ptr() as *const [G; OUT_331]) }; __ret } else { aiur_fn_331(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __v_25: G = __r_arr[2]; + let __v_26: G = __r_arr[3]; + let __v_27: G = __r_arr[4]; + let __v_28: G = __r_arr[5]; + let __v_29: G = __r_arr[6]; + let __v_30: G = __r_arr[7]; + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __v_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_334] = [__v_32]; + record.function_queries[334].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +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_335], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(2); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_335] = [__v_16]; + record.function_queries[335].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_336], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(2); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = { let __values: [G; 10] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_13]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_14, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_336] = [__v_16]; + record.function_queries[336].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_337: usize = 3; +const IN_337: usize = 3; +const OUT_337: usize = 2; +fn aiur_fn_337( + inp: [G; IN_337], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_337], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_337] = [__v_6, __v_7]; + record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_337] = [__v_7, __v_2]; + record.function_queries[337].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_2 + __v_7); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_337] = [__v_9, __v_10]; + record.function_queries[337].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_338: usize = 3; +const IN_338: usize = 3; +const OUT_338: usize = 1; +fn aiur_fn_338( + inp: [G; IN_338], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_338], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __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_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(2); + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 4] = [__v_13, __v_1, __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_338] = [__v_18]; + record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(2); + 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 __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_16, __v_2, __v_19, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_22: G = G::from_u64(3); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_22, __v_21, __v_15, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_338] = [__v_24]; + record.function_queries[338].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +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_339], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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() { + 7u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_10, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + match __v_8.as_canonical_u64() { + 1u64 => { + match __v_12.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_338] = { let __args: [G; IN_338] = [__v_4, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[338].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_338] = unsafe { *(result.output.as_ptr() as *const [G; OUT_338]) }; __ret } else { aiur_fn_338(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_339] = [__v_14]; + record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_339] = [__v_0]; + record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_339] = [__v_0]; + record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_339] = [__v_0]; + record.function_queries[339].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_339] = [__v_0]; + record.function_queries[339].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 = 2; +fn aiur_fn_340( + inp: [G; IN_340], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_340], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 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() { + 7u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_340] = [__v_6, __v_4]; + record.function_queries[340].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(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_340] = [__v_6, __v_9]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 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_340] = [__v_9, __v_12]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 10] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_340] = [__v_9, __v_12]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + 3u64 => { + let __r_arr: [G; OUT_341] = { let __args: [G; IN_341] = [__v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[341].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_341] = unsafe { *(result.output.as_ptr() as *const [G; OUT_341]) }; __ret } else { aiur_fn_341(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __ret: [G; OUT_340] = [__v_6, __v_7]; + record.function_queries[340].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(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_340] = [__v_6, __v_9]; + record.function_queries[340].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_341: usize = 3; +const IN_341: usize = 3; +const OUT_341: usize = 2; +fn aiur_fn_341( + inp: [G; IN_341], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_341], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_341] = [__v_12, __v_13]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(1); + let __v_14: G = G::from_u64(1); + let __v_15: G = { let __values: [G; 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_341] = [__v_12, __v_15]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_341] = [__v_10, __v_13]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_341] = [__v_7, __v_10]; + record.function_queries[341].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_342: usize = 1; +const IN_342: usize = 1; +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_342], 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_342] = [__v_4]; + record.function_queries[342].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_343: usize = 1; +const IN_343: usize = 1; +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_343], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { 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_9: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { 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_35: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { 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_37: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { 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_43: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_55]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_59]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { 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_61: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { 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_63: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_70: G = __r_arr[0]; + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_71]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_72: G = __r_arr[0]; + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { 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_73: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_75]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_76: G = __r_arr[0]; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_78: G = __r_arr[0]; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __v_79: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_80: G = __r_arr[0]; + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __v_81: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_82: G = __r_arr[0]; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { 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_83: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __v_85: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_85]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_86: G = __r_arr[0]; + let __v_87: G = (__v_84 + __v_86); + let __v_88: G = (__v_82 + __v_87); + let __v_89: G = (__v_80 + __v_88); + let __v_90: G = (__v_78 + __v_89); + let __v_91: G = (__v_76 + __v_90); + let __v_92: G = (__v_74 + __v_91); + let __v_93: G = (__v_72 + __v_92); + let __v_94: G = (__v_70 + __v_93); + let __v_95: G = (__v_68 + __v_94); + let __v_96: G = (__v_66 + __v_95); + let __v_97: G = (__v_64 + __v_96); + let __v_98: G = (__v_62 + __v_97); + let __v_99: G = (__v_60 + __v_98); + let __v_100: G = (__v_58 + __v_99); + let __v_101: G = (__v_56 + __v_100); + let __v_102: G = (__v_54 + __v_101); + let __v_103: G = (__v_52 + __v_102); + let __v_104: G = (__v_50 + __v_103); + let __v_105: G = (__v_48 + __v_104); + let __v_106: G = (__v_46 + __v_105); + let __v_107: G = (__v_44 + __v_106); + let __v_108: G = (__v_42 + __v_107); + let __v_109: G = (__v_40 + __v_108); + let __v_110: G = (__v_38 + __v_109); + let __v_111: G = (__v_36 + __v_110); + let __v_112: G = (__v_34 + __v_111); + let __v_113: G = (__v_32 + __v_112); + let __v_114: G = (__v_30 + __v_113); + let __v_115: G = (__v_28 + __v_114); + let __v_116: G = (__v_26 + __v_115); + let __v_117: G = (__v_24 + __v_116); + let __v_118: G = (__v_22 + __v_117); + let __v_119: G = (__v_20 + __v_118); + let __v_120: G = (__v_18 + __v_119); + let __v_121: G = (__v_16 + __v_120); + let __v_122: G = (__v_14 + __v_121); + let __v_123: G = (__v_12 + __v_122); + let __v_124: G = (__v_10 + __v_123); + let __v_125: G = (__v_8 + __v_124); + let __v_126: G = (__v_6 + __v_125); + let __v_127: G = (__v_4 + __v_126); + let __v_128: G = (__v_2 + __v_127); + let __ret: [G; OUT_343] = [__v_128]; + record.function_queries[343].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_344: usize = 5; +const IN_344: usize = 5; +const OUT_344: usize = 2; +fn aiur_fn_344( + inp: [G; IN_344], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __v_4: G = inp[4]; + 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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_198] = unsafe { *(result.output.as_ptr() as *const [G; OUT_198]) }; __ret } else { aiur_fn_198(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_279] = { let __args: [G; IN_279] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[279].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_279] = unsafe { *(result.output.as_ptr() as *const [G; OUT_279]) }; __ret } else { aiur_fn_279(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_344] = [__v_12, __v_16]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_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 __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(1); + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_344] = [__v_19, __v_22]; + record.function_queries[344].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 __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_344] = [__v_17, __v_21]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 0u64 => { + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_10.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_344] = [__v_12, __v_16]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_14, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_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 __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(1); + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_344] = [__v_19, __v_22]; + record.function_queries[344].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 __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_344] = [__v_17, __v_21]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __r_arr: [G; OUT_345] = { let __args: [G; IN_345] = [__v_0, __v_1, __v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[345].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_345] = unsafe { *(result.output.as_ptr() as *const [G; OUT_345]) }; __ret } else { aiur_fn_345(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_344] = [__v_10, __v_11]; + record.function_queries[344].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_345: usize = 6; +const IN_345: usize = 6; +const OUT_345: usize = 2; +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 = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = G::from_u64(2); + let __v_7: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_6.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_345] = [__v_8, __v_12]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_10, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_13, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + match __v_14.as_canonical_u64() { + 1u64 => { + match __v_16.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_346] = { let __args: [G; IN_346] = [__v_0, __v_15, __v_17, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[346].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_346] = unsafe { *(result.output.as_ptr() as *const [G; OUT_346]) }; __ret } else { aiur_fn_346(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + match __v_18.as_canonical_u64() { + 1u64 => { + let __v_20: G = G::from_u64(2); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_19, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_345] = [__v_22, __v_23]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_345] = [__v_20, __v_24]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { 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_345] = [__v_18, __v_22]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { 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_345] = [__v_18, __v_22]; + record.function_queries[345].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_346: usize = 4; +const IN_346: usize = 4; +const OUT_346: usize = 2; +fn aiur_fn_346( + inp: [G; IN_346], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_346], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_6, __v_9]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_281] = { let __args: [G; IN_281] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[281].get_mut(&__args[..]) { 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_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_8, __v_11]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_282] = { let __args: [G; IN_282] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[282].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_282] = unsafe { *(result.output.as_ptr() as *const [G; OUT_282]) }; __ret } else { aiur_fn_282(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(1); + let __r_arr: [G; OUT_319] = { let __args: [G; IN_319] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[319].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_319] = unsafe { *(result.output.as_ptr() as *const [G; OUT_319]) }; __ret } else { aiur_fn_319(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_10, __v_13]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __r_arr: [G; OUT_325] = { let __args: [G; IN_325] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[325].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_325] = unsafe { *(result.output.as_ptr() as *const [G; OUT_325]) }; __ret } else { aiur_fn_325(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_12, __v_15]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { 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_12: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(1); + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_14, __v_17]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_284] = { let __args: [G; IN_284] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[284].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_284] = unsafe { *(result.output.as_ptr() as *const [G; OUT_284]) }; __ret } else { aiur_fn_284(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + match __v_15.as_canonical_u64() { + 1u64 => { + let __v_16: G = G::from_u64(1); + let __r_arr: [G; OUT_327] = { let __args: [G; IN_327] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[327].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_327] = unsafe { *(result.output.as_ptr() as *const [G; OUT_327]) }; __ret } else { aiur_fn_327(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_16, __v_19]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_283] = { let __args: [G; IN_283] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[283].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_283] = unsafe { *(result.output.as_ptr() as *const [G; OUT_283]) }; __ret } else { aiur_fn_283(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + match __v_17.as_canonical_u64() { + 1u64 => { + let __v_18: G = G::from_u64(1); + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_18, __v_21]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_287] = { let __args: [G; IN_287] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[287].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_287] = unsafe { *(result.output.as_ptr() as *const [G; OUT_287]) }; __ret } else { aiur_fn_287(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + match __v_19.as_canonical_u64() { + 1u64 => { + let __v_20: G = G::from_u64(1); + let __r_arr: [G; OUT_332] = { let __args: [G; IN_332] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[332].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_332] = unsafe { *(result.output.as_ptr() as *const [G; OUT_332]) }; __ret } else { aiur_fn_332(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_20, __v_23]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_288] = { let __args: [G; IN_288] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[288].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_288] = unsafe { *(result.output.as_ptr() as *const [G; OUT_288]) }; __ret } else { aiur_fn_288(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + match __v_21.as_canonical_u64() { + 1u64 => { + let __v_22: G = G::from_u64(1); + let __r_arr: [G; OUT_333] = { let __args: [G; IN_333] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[333].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_333] = unsafe { *(result.output.as_ptr() as *const [G; OUT_333]) }; __ret } else { aiur_fn_333(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_22, __v_25]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_289] = { let __args: [G; IN_289] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[289].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_289] = unsafe { *(result.output.as_ptr() as *const [G; OUT_289]) }; __ret } else { aiur_fn_289(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + match __v_23.as_canonical_u64() { + 1u64 => { + let __v_24: G = G::from_u64(1); + let __r_arr: [G; OUT_334] = { let __args: [G; IN_334] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[334].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_334] = unsafe { *(result.output.as_ptr() as *const [G; OUT_334]) }; __ret } else { aiur_fn_334(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_24, __v_27]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_290] = { let __args: [G; IN_290] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[290].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_290] = unsafe { *(result.output.as_ptr() as *const [G; OUT_290]) }; __ret } else { aiur_fn_290(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_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_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 !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_27: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_26, __v_29]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_291] = { let __args: [G; IN_291] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[291].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_291] = unsafe { *(result.output.as_ptr() as *const [G; OUT_291]) }; __ret } else { aiur_fn_291(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + match __v_27.as_canonical_u64() { + 1u64 => { + let __v_28: G = G::from_u64(1); + let __r_arr: [G; OUT_336] = { let __args: [G; IN_336] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[336].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_336] = unsafe { *(result.output.as_ptr() as *const [G; OUT_336]) }; __ret } else { aiur_fn_336(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_28, __v_31]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_292] = { let __args: [G; IN_292] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[292].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_292] = unsafe { *(result.output.as_ptr() as *const [G; OUT_292]) }; __ret } else { aiur_fn_292(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + match __v_29.as_canonical_u64() { + 1u64 => { + let __v_30: G = G::from_u64(1); + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_31, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_30, __v_32]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_293] = { let __args: [G; IN_293] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[293].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_293] = unsafe { *(result.output.as_ptr() as *const [G; OUT_293]) }; __ret } else { aiur_fn_293(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + match __v_31.as_canonical_u64() { + 1u64 => { + let __v_32: G = G::from_u64(1); + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_33, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __ret: [G; OUT_346] = [__v_32, __v_34]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = { 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_346] = [__v_32, __v_36]; + record.function_queries[346].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_29.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +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_347], 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_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + break '__mc_0 [__v_2]; + }, + _ => { + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + break '__mc_0 [__v_2]; + }, +} + }; + let __v_2: G = __mc_out___mc_0[0]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_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(2); + 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 = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_6, __v_5, __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_347] = [__v_11]; + record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(7); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_347] = [__v_12]; + record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(7); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(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 __v_20: G = { let __values: [G; 10] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __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 = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_6, __v_7, __v_20, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_347] = [__v_22]; + record.function_queries[347].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +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_348], 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_348] = [__v_11]; + record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_11: G = G::from_u64(256); + let __v_12: G = (__v_11 * __v_3); + let __v_13: G = G::from_u64(65536); + let __v_14: G = (__v_13 * __v_4); + let __v_15: G = G::from_u64(16777216); + let __v_16: G = (__v_15 * __v_5); + let __v_17: G = (__v_14 + __v_16); + let __v_18: G = (__v_12 + __v_17); + let __v_19: G = (__v_2 + __v_18); + let __ret: [G; OUT_348] = [__v_19]; + record.function_queries[348].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_349: usize = 4; +const IN_349: usize = 4; +const OUT_349: usize = 2; +fn aiur_fn_349( + inp: [G; IN_349], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_349], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_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 }; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_349] = [__v_7, __v_11]; + record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_350] = { let __args: [G; IN_350] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[350].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_350] = unsafe { *(result.output.as_ptr() as *const [G; OUT_350]) }; __ret } else { aiur_fn_350(__args, record, io_buffer, __cu)? } }; + let __v_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() { + 0u64 => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_349] = [__v_15, __v_19]; + record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_14, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_15, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + match __v_16.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { 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_349] = [__v_18, __v_22]; + record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_13, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_18, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + match __v_19.as_canonical_u64() { + 0u64 => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = { 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_349] = [__v_21, __v_25]; + record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(2); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(1); + let __v_31: G = G::from_u64(1); + let __v_32: G = { let __values: [G; 10] = [__v_30, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __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 = { let __values: [G; 10] = [__v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_32]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_328] = { let __args: [G; IN_328] = [__v_33, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[328].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_328] = unsafe { *(result.output.as_ptr() as *const [G; OUT_328]) }; __ret } else { aiur_fn_328(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_326] = { let __args: [G; IN_326] = [__v_17, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[326].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_326] = unsafe { *(result.output.as_ptr() as *const [G; OUT_326]) }; __ret } else { aiur_fn_326(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = G::from_u64(1); + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __ret: [G; OUT_349] = [__v_36, __v_37]; + record.function_queries[349].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_350: usize = 2; +const IN_350: usize = 2; +const OUT_350: usize = 3; +fn aiur_fn_350( + inp: [G; IN_350], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_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 }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_244] = { let __args: [G; IN_244] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[244].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_244] = unsafe { *(result.output.as_ptr() as *const [G; OUT_244]) }; __ret } else { aiur_fn_244(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + 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 !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_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(2); + let __v_13: G = (__v_11 - __v_12); + match __v_13.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __ret: [G; OUT_350] = [__v_14, __v_16, __v_18]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 4] = [__v_15, __v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_19, __v_20, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_350] = [__v_14, __v_18, __v_22]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __v_11: G = G::from_u64(143); + let __v_12: G = G::from_u64(220); + let __v_13: G = G::from_u64(134); + let __v_14: G = G::from_u64(159); + let __v_15: G = G::from_u64(123); + let __v_16: G = G::from_u64(122); + let __v_17: G = G::from_u64(162); + let __v_18: G = G::from_u64(183); + let __v_19: G = G::from_u64(181); + let __v_20: G = G::from_u64(146); + let __v_21: G = G::from_u64(155); + let __v_22: G = G::from_u64(162); + let __v_23: G = G::from_u64(66); + let __v_24: G = G::from_u64(237); + let __v_25: G = G::from_u64(137); + let __v_26: G = G::from_u64(156); + let __v_27: G = G::from_u64(226); + let __v_28: G = G::from_u64(215); + let __v_29: G = G::from_u64(197); + let __v_30: G = G::from_u64(212); + let __v_31: G = G::from_u64(45); + let __v_32: G = G::from_u64(241); + let __v_33: G = G::from_u64(212); + let __v_34: G = G::from_u64(226); + let __v_35: G = G::from_u64(57); + let __v_36: G = G::from_u64(54); + let __v_37: G = G::from_u64(144); + let __v_38: G = G::from_u64(207); + let __v_39: G = G::from_u64(168); + let __v_40: G = G::from_u64(94); + let __v_41: G = G::from_u64(148); + let __v_42: G = G::from_u64(210); + let __v_43: G = { let __values: [G; 32] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_8, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + match __v_44.as_canonical_u64() { + 0u64 => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = { let __values: [G; 4] = [__v_46, __v_47, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = { let __values: [G; 4] = [__v_50, __v_51, __v_52, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_350] = [__v_45, __v_49, __v_53]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(2); + let __v_47: G = { let __a_val = __v_45.as_canonical_u64(); let __b_val = __v_46.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_47.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = { let __values: [G; 4] = [__v_49, __v_50, __v_51, __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 __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = { let __values: [G; 4] = [__v_53, __v_54, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_350] = [__v_48, __v_52, __v_56]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_50: G = __r_arr[0]; + let __v_51: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_52: G = __loaded[0]; + let __v_53: G = __loaded[1]; + let __v_54: G = __loaded[2]; + let __v_55: G = __loaded[3]; + match __v_52.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { 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_57: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_56, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + match __v_58.as_canonical_u64() { + 0u64 => { + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = { let __values: [G; 4] = [__v_60, __v_61, __v_62, __v_62]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = G::from_u64(0); + let __v_67: G = { let __values: [G; 4] = [__v_64, __v_65, __v_66, __v_66]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_59, __v_63, __v_67]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_59: G = __r_arr[0]; + let __v_60: G = G::from_u64(1); + let __v_61: G = (__v_59 - __v_60); + match __v_61.as_canonical_u64() { + 0u64 => { + let __v_62: G = G::from_u64(1); + let __v_63: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_51, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __ret: [G; OUT_350] = [__v_62, __v_64, __v_66]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = { let __values: [G; 4] = [__v_63, __v_64, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = G::from_u64(0); + let __v_68: G = G::from_u64(0); + let __v_69: G = G::from_u64(0); + let __v_70: G = { let __values: [G; 4] = [__v_67, __v_68, __v_69, __v_69]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_62, __v_66, __v_70]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_58.as_canonical_u64())); + }, + } + }, + _ => { + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = { let __values: [G; 4] = [__v_57, __v_58, __v_59, __v_59]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = { let __values: [G; 4] = [__v_61, __v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_350] = [__v_56, __v_60, __v_64]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_47.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_44.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = 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_350] = [__v_8, __v_12, __v_16]; + record.function_queries[350].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_351: usize = 4; +const IN_351: usize = 4; +const OUT_351: usize = 2; +fn aiur_fn_351( + inp: [G; IN_351], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !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_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(3); + let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_351] = [__v_7, __v_11]; + record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(2); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_8, __v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_352] = { let __args: [G; IN_352] = [__v_8, __v_12, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[352].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_352] = unsafe { *(result.output.as_ptr() as *const [G; OUT_352]) }; __ret } else { aiur_fn_352(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + match __v_13.as_canonical_u64() { + 0u64 => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_351] = [__v_17, __v_21]; + record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + match __v_15.as_canonical_u64() { + 0u64 => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_351] = [__v_17, __v_21]; + record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_17: G = G::from_u64(1); + let __r_arr: [G; OUT_314] = { let __args: [G; IN_314] = [__v_16, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = (__v_17 - __v_18); + let __v_20: G = G::from_u64(1); + let __r_arr: [G; OUT_347] = { let __args: [G; IN_347] = [__v_19, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[347].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_347] = unsafe { *(result.output.as_ptr() as *const [G; OUT_347]) }; __ret } else { aiur_fn_347(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_351] = [__v_20, __v_21]; + record.function_queries[351].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_352: usize = 5; +const IN_352: usize = 5; +const OUT_352: usize = 2; +fn aiur_fn_352( + inp: [G; IN_352], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_352], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = G::from_u64(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_1, __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_5, __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 __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 10] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_352] = [__v_14, __v_17]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_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]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = __loaded[3]; + match __v_14.as_canonical_u64() { + 7u64 => { + match __v_15.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(1); + let __ret: [G; OUT_352] = [__v_18, __v_16]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(1); + let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_352] = [__v_18, __v_21]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(1); + let __v_21: G = { let __values: [G; 10] = [__v_19, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_352] = [__v_18, __v_21]; + record.function_queries[352].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_353: usize = 5; +const IN_353: usize = 5; +const OUT_353: usize = 2; +fn aiur_fn_353( + inp: [G; IN_353], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_353], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_243] = { let __args: [G; IN_243] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[243].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_243] = unsafe { *(result.output.as_ptr() as *const [G; OUT_243]) }; __ret } else { aiur_fn_243(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_349] = { let __args: [G; IN_349] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[349].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_349] = unsafe { *(result.output.as_ptr() as *const [G; OUT_349]) }; __ret } else { aiur_fn_349(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __ret: [G; OUT_353] = [__v_7, __v_8]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_245] = { let __args: [G; IN_245] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[245].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_245] = unsafe { *(result.output.as_ptr() as *const [G; OUT_245]) }; __ret } else { aiur_fn_245(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_353] = [__v_9, __v_10]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_246] = { let __args: [G; IN_246] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[246].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_246] = unsafe { *(result.output.as_ptr() as *const [G; OUT_246]) }; __ret } else { aiur_fn_246(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_354] = { let __args: [G; IN_354] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[354].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_354] = unsafe { *(result.output.as_ptr() as *const [G; OUT_354]) }; __ret } else { aiur_fn_354(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_353] = [__v_11, __v_12]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = { 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_353] = [__v_11, __v_15]; + record.function_queries[353].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_354: usize = 4; +const IN_354: usize = 4; +const OUT_354: usize = 2; +fn aiur_fn_354( + inp: [G; IN_354], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_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 }; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_354] = [__v_7, __v_11]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_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 }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + match __v_11.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_247] = { let __args: [G; IN_247] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[247].get_mut(&__args[..]) { 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_16: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + match __v_17.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { 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_354] = [__v_18, __v_22]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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 __v_19: G = G::from_u64(4); + let __v_20: G = { let __a_val = __v_18.as_canonical_u64(); let __b_val = __v_19.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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 __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 = { 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_354] = [__v_21, __v_25]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_23: G = __r_arr[0]; + let __v_24: 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_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_25: G = __loaded[0]; + let __v_26: G = __loaded[1]; + let __v_27: G = __loaded[2]; + let __v_28: G = __loaded[3]; + match __v_25.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_242] = { let __args: [G; IN_242] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[242].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + match __v_31.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = { 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_354] = [__v_32, __v_36]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_32: G = __r_arr[0]; + let __v_33: G = G::from_u64(1); + 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() { + 1u64 => { + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = { let __values: [G; 4] = [__v_36, __v_37, __v_38, __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_354] = [__v_35, __v_39]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_35: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_24, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __v_37: G = G::from_u64(2); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = G::from_u64(3); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __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 = G::from_u64(0); + let __v_44: G = G::from_u64(1); + let __v_45: G = G::from_u64(1); + let __v_46: G = { let __values: [G; 3] = [__v_44, __v_45, __v_45]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = { let __values: [G; 3] = [__v_43, __v_40, __v_46]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_48: G = { let __values: [G; 3] = [__v_42, __v_38, __v_47]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = { let __values: [G; 3] = [__v_41, __v_36, __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 __r_arr: [G; OUT_351] = { let __args: [G; IN_351] = [__v_49, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[351].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_351] = unsafe { *(result.output.as_ptr() as *const [G; OUT_351]) }; __ret } else { aiur_fn_351(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __v_51: G = __r_arr[1]; + let __ret: [G; OUT_354] = [__v_50, __v_51]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_34.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); + }, + } + }, + _ => { + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = { 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_354] = [__v_29, __v_33]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_354] = [__v_15, __v_19]; + record.function_queries[354].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_355: usize = 5; +const IN_355: usize = 5; +const OUT_355: usize = 2; +fn aiur_fn_355( + inp: [G; IN_355], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_355], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_269] = { let __args: [G; IN_269] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[269].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_269] = unsafe { *(result.output.as_ptr() as *const [G; OUT_269]) }; __ret } else { aiur_fn_269(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_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_356] = { let __args: [G; IN_356] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_355] = [__v_7, __v_8]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_271] = { let __args: [G; IN_271] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[271].get_mut(&__args[..]) { 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_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_358] = { let __args: [G; IN_358] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[358].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_358] = unsafe { *(result.output.as_ptr() as *const [G; OUT_358]) }; __ret } else { aiur_fn_358(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_355] = [__v_9, __v_10]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_273] = { let __args: [G; IN_273] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[273].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_273] = unsafe { *(result.output.as_ptr() as *const [G; OUT_273]) }; __ret } else { aiur_fn_273(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_359] = { let __args: [G; IN_359] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[359].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_359] = unsafe { *(result.output.as_ptr() as *const [G; OUT_359]) }; __ret } else { aiur_fn_359(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_355] = [__v_11, __v_12]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_272] = { let __args: [G; IN_272] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[272].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_272] = unsafe { *(result.output.as_ptr() as *const [G; OUT_272]) }; __ret } else { aiur_fn_272(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_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_357] = { let __args: [G; IN_357] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_355] = [__v_13, __v_14]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_267] = { let __args: [G; IN_267] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[267].get_mut(&__args[..]) { 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_13: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_268] = { let __args: [G; IN_268] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[268].get_mut(&__args[..]) { 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_15: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = (__v_14 + __v_16); + match __v_17.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { 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_355] = [__v_18, __v_22]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + 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 !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 __v_19: G = G::from_u64(1); + let __v_20: G = { let __a_val = __v_18.as_canonical_u64(); let __b_val = __v_19.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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 __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 = { 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_355] = [__v_21, __v_25]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_22, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_360] = { let __args: [G; IN_360] = [__v_23, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[360].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_360] = unsafe { *(result.output.as_ptr() as *const [G; OUT_360]) }; __ret } else { aiur_fn_360(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __ret: [G; OUT_355] = [__v_24, __v_25]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_361] = { let __args: [G; IN_361] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[361].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_361] = unsafe { *(result.output.as_ptr() as *const [G; OUT_361]) }; __ret } else { aiur_fn_361(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __ret: [G; OUT_355] = [__v_24, __v_25]; + record.function_queries[355].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_356: usize = 0; +const IN_356: usize = 0; +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_356], 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); + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(7); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_356] = [__v_16]; + record.function_queries[356].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_357: usize = 0; +const IN_357: usize = 0; +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_357], 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 __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __values: [G; 10] = [__v_9, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 10] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(7); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_12, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_357] = [__v_16]; + record.function_queries[357].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_358: usize = 2; +const IN_358: usize = 2; +const OUT_358: usize = 2; +fn aiur_fn_358( + inp: [G; IN_358], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_358], 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_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_2: G = __r_arr[0]; + let __v_3: G = G::from_u64(3); + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_358] = [__v_5, __v_9]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(2); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __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 }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_270] = { let __args: [G; IN_270] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[270].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_270] = unsafe { *(result.output.as_ptr() as *const [G; OUT_270]) }; __ret } else { aiur_fn_270(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + match __v_15.as_canonical_u64() { + 1u64 => { + let __v_16: G = G::from_u64(1); + let __r_arr: [G; OUT_356] = { let __args: [G; IN_356] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[356].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_356] = unsafe { *(result.output.as_ptr() as *const [G; OUT_356]) }; __ret } else { aiur_fn_356(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_358] = [__v_16, __v_17]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = { 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_358] = [__v_16, __v_20]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = { 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_358] = [__v_13, __v_17]; + record.function_queries[358].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_359: usize = 2; +const IN_359: usize = 2; +const OUT_359: usize = 2; +fn aiur_fn_359( + inp: [G; IN_359], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_359], 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_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_2: G = __r_arr[0]; + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_359] = [__v_5, __v_9]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __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 }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_275] = { let __args: [G; IN_275] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[275].get_mut(&__args[..]) { 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_14: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_274] = { let __args: [G; IN_274] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[274].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_274] = unsafe { *(result.output.as_ptr() as *const [G; OUT_274]) }; __ret } else { aiur_fn_274(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = (__v_15 + __v_17); + match __v_18.as_canonical_u64() { + 0u64 => { + 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 = { 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_359] = [__v_19, __v_23]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_19: G = G::from_u64(1); + let __r_arr: [G; OUT_357] = { let __args: [G; IN_357] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[357].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_357] = unsafe { *(result.output.as_ptr() as *const [G; OUT_357]) }; __ret } else { aiur_fn_357(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_359] = [__v_19, __v_20]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = { 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_359] = [__v_13, __v_17]; + record.function_queries[359].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_360: usize = 2; +const IN_360: usize = 2; +const OUT_360: usize = 2; +fn aiur_fn_360( + inp: [G; IN_360], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_360], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = (__v_8 + __v_10); + match __v_11.as_canonical_u64() { + 0u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { 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_360] = [__v_12, __v_16]; + record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_360] = [__v_12, __v_0]; + record.function_queries[360].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 __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_360] = [__v_6, __v_10]; + record.function_queries[360].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_361: usize = 1; +const IN_361: usize = 1; +const OUT_361: usize = 2; +fn aiur_fn_361( + inp: [G; IN_361], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_361], 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + match __v_1.as_canonical_u64() { + 7u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_361] = [__v_5, __v_0]; + record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_361] = [__v_5, __v_9]; + record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_361] = [__v_5, __v_9]; + record.function_queries[361].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_362: usize = 7; +const IN_362: usize = 7; +const OUT_362: usize = 2; +fn aiur_fn_362( + inp: [G; IN_362], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_362], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { 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_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_252] = { let __args: [G; IN_252] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[252].get_mut(&__args[..]) { 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_9: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_253] = { let __args: [G; IN_253] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[253].get_mut(&__args[..]) { 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_11: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_255] = { let __args: [G; IN_255] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[255].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_255] = unsafe { *(result.output.as_ptr() as *const [G; OUT_255]) }; __ret } else { aiur_fn_255(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_254] = { let __args: [G; IN_254] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[254].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_254] = unsafe { *(result.output.as_ptr() as *const [G; OUT_254]) }; __ret } else { aiur_fn_254(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_256] = { let __args: [G; IN_256] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[256].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_256] = unsafe { *(result.output.as_ptr() as *const [G; OUT_256]) }; __ret } else { aiur_fn_256(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = (__v_16 + __v_18); + let __v_20: G = (__v_14 + __v_19); + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_365] = { let __args: [G; IN_365] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[365].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_365] = unsafe { *(result.output.as_ptr() as *const [G; OUT_365]) }; __ret } else { aiur_fn_365(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __ret: [G; OUT_362] = [__v_21, __v_22]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_21: G = (__v_10 + __v_12); + let __v_22: G = (__v_8 + __v_21); + match __v_22.as_canonical_u64() { + 0u64 => { + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __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_362] = [__v_23, __v_27]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(2); + let __v_25: G = { let __a_val = __v_23.as_canonical_u64(); let __b_val = __v_24.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_25.as_canonical_u64() { + 1u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = { 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_362] = [__v_26, __v_30]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_367] = { let __args: [G; IN_367] = [__v_8, __v_10, __v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[367].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_367] = unsafe { *(result.output.as_ptr() as *const [G; OUT_367]) }; __ret } else { aiur_fn_367(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __ret: [G; OUT_362] = [__v_26, __v_27]; + record.function_queries[362].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_363: usize = 2; +const IN_363: usize = 2; +const OUT_363: usize = 3; +fn aiur_fn_363( + inp: [G; IN_363], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_363], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __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() { + 3u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = (__v_12 + __v_14); + match __v_15.as_canonical_u64() { + 0u64 => { + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(1); + let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_363] = [__v_16, __v_17, __v_20]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_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_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + let __v_19: G = __loaded[3]; + match __v_16.as_canonical_u64() { + 7u64 => { + match __v_17.as_canonical_u64() { + 0u64 => { + let __v_20: G = G::from_u64(1); + let __ret: [G; OUT_363] = [__v_20, __v_14, __v_18]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __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_363] = [__v_20, __v_21, __v_24]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __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_363] = [__v_20, __v_21, __v_24]; + record.function_queries[363].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 = 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_363] = [__v_10, __v_11, __v_14]; + record.function_queries[363].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 __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_363] = [__v_6, __v_7, __v_10]; + record.function_queries[363].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_364: usize = 3; +const IN_364: usize = 3; +const OUT_364: usize = 2; +fn aiur_fn_364( + inp: [G; IN_364], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_257] = { let __args: [G; IN_257] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[257].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + break '__mc_0 [__v_3]; + }, + _ => { + let __r_arr: [G; OUT_258] = { let __args: [G; IN_258] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[258].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_258] = unsafe { *(result.output.as_ptr() as *const [G; OUT_258]) }; __ret } else { aiur_fn_258(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + break '__mc_0 [__v_3]; + }, +} + }; + let __v_3: G = __mc_out___mc_0[0]; + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_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(2); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_7, __v_6, __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 __v_13: G = G::from_u64(1); + let __v_14: G = G::from_u64(3); + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_14, __v_12, __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 __ret: [G; OUT_364] = [__v_13, __v_17]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_364] = [__v_7, __v_11]; + record.function_queries[364].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_365: usize = 6; +const IN_365: usize = 6; +const OUT_365: usize = 2; +fn aiur_fn_365( + inp: [G; IN_365], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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 __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !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_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(2); + let __v_8: G = { let __a_val = __v_6.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_8.as_canonical_u64() { + 1u64 => { + 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 = { 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_365] = [__v_9, __v_13]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_10, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_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 __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_12, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + match __v_16.as_canonical_u64() { + 1u64 => { + 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 = { 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_365] = [__v_19, __v_23]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_1, __v_2, __v_10, __v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __ret: [G; OUT_365] = [__v_19, __v_20]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_366] = { let __args: [G; IN_366] = [__v_0, __v_1, __v_2, __v_10, __v_12, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[366].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_366] = unsafe { *(result.output.as_ptr() as *const [G; OUT_366]) }; __ret } else { aiur_fn_366(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __ret: [G; OUT_365] = [__v_16, __v_17]; + record.function_queries[365].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_366: usize = 8; +const IN_366: usize = 8; +const OUT_366: usize = 2; +fn aiur_fn_366( + inp: [G; IN_366], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_3, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_8, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = __r_arr[2]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_363] = { let __args: [G; IN_363] = [__v_9, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[363].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_363] = unsafe { *(result.output.as_ptr() as *const [G; OUT_363]) }; __ret } else { aiur_fn_363(__args, record, io_buffer, __cu)? } }; + let __v_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 __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_11, __v_12, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + match __v_16.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_364] = { let __args: [G; IN_364] = [__v_14, __v_15, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[364].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_364] = unsafe { *(result.output.as_ptr() as *const [G; OUT_364]) }; __ret } else { aiur_fn_364(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + match __v_18.as_canonical_u64() { + 1u64 => { + let __v_20: G = G::from_u64(2); + let __v_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 4] = [__v_20, __v_0, __v_1, __v_21]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = G::from_u64(3); + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 4] = [__v_23, __v_22, __v_17, __v_24]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = G::from_u64(3); + let __v_27: G = G::from_u64(0); + let __v_28: G = { let __values: [G; 4] = [__v_26, __v_25, __v_19, __v_27]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = G::from_u64(2); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_2, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_28, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __ret: [G; OUT_366] = [__v_31, __v_32]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __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_366] = [__v_20, __v_24]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { 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_366] = [__v_18, __v_22]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __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_366] = [__v_16, __v_20]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = { 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_366] = [__v_13, __v_17]; + record.function_queries[366].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_367: usize = 9; +const IN_367: usize = 9; +const OUT_367: usize = 2; +fn aiur_fn_367( + inp: [G; IN_367], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __v_3: G = inp[3]; + 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]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_13, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = { 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_367] = [__v_16, __v_20]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(2); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(1); + let __v_22: G = { let __values: [G; 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 __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_18, __v_19, __v_22, __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_251] = { let __args: [G; IN_251] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[251].get_mut(&__args[..]) { 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_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_25, __v_8, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = { 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_367] = [__v_29, __v_33]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_29: G = G::from_u64(2); + let __v_30: G = G::from_u64(1); + let __v_31: G = G::from_u64(1); + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = G::from_u64(0); + let __v_34: G = { let __values: [G; 4] = [__v_29, __v_28, __v_32, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = G::from_u64(3); + let __v_36: G = G::from_u64(0); + let __v_37: G = { let __values: [G; 4] = [__v_35, __v_34, __v_17, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = G::from_u64(3); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 4] = [__v_38, __v_37, __v_12, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = G::from_u64(2); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_5, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_40, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = G::from_u64(1); + let __ret: [G; OUT_367] = [__v_44, __v_43]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __r_arr: [G; OUT_368] = { let __args: [G; IN_368] = [__v_0, __v_1, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[368].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_368] = unsafe { *(result.output.as_ptr() as *const [G; OUT_368]) }; __ret } else { aiur_fn_368(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_367] = [__v_9, __v_10]; + record.function_queries[367].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_368: usize = 8; +const IN_368: usize = 8; +const OUT_368: usize = 2; +fn aiur_fn_368( + inp: [G; IN_368], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_368], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_11, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_12, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { 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_368] = [__v_18, __v_22]; + record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + match __v_16.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { 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_368] = [__v_18, __v_22]; + record.function_queries[368].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_314] = { let __args: [G; IN_314] = [__v_15, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[314].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_314] = unsafe { *(result.output.as_ptr() as *const [G; OUT_314]) }; __ret } else { aiur_fn_314(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + break '__mc_0 [__v_18]; + }, + 0u64 => { + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_15, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + break '__mc_0 [__v_18]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, +} + }; + let __v_18: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_369] = { let __args: [G; IN_369] = [__v_0, __v_1, __v_18, __v_9, __v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[369].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_369] = unsafe { *(result.output.as_ptr() as *const [G; OUT_369]) }; __ret } else { aiur_fn_369(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __ret: [G; OUT_368] = [__v_19, __v_20]; + record.function_queries[368].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_369: usize = 11; +const IN_369: usize = 11; +const OUT_369: usize = 2; +fn aiur_fn_369( + inp: [G; IN_369], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_369], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { 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_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_11, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + match __v_13.as_canonical_u64() { + 0u64 => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_15, __v_19]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_248] = { let __args: [G; IN_248] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[248].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_248] = unsafe { *(result.output.as_ptr() as *const [G; OUT_248]) }; __ret } else { aiur_fn_248(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_15, __v_10, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + match __v_17.as_canonical_u64() { + 0u64 => { + 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 = { 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_369] = [__v_19, __v_23]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_2.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_305] = { let __args: [G; IN_305] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[305].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_305] = unsafe { *(result.output.as_ptr() as *const [G; OUT_305]) }; __ret } else { aiur_fn_305(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_19, __v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + break '__mc_0 [__v_21, __v_22]; + }, + 0u64 => { + let __r_arr: [G; OUT_306] = { let __args: [G; IN_306] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[306].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_306] = unsafe { *(result.output.as_ptr() as *const [G; OUT_306]) }; __ret } else { aiur_fn_306(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_19, __v_10, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + break '__mc_0 [__v_21, __v_22]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, +} + }; + let __v_19: G = __mc_out___mc_0[0]; + let __v_20: G = __mc_out___mc_0[1]; + match __v_19.as_canonical_u64() { + 0u64 => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = { 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_369] = [__v_21, __v_25]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_21: G = G::from_u64(1); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = G::from_u64(0); + let __v_26: G = { let __values: [G; 3] = [__v_21, __v_24, __v_25]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = G::from_u64(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 = { let __values: [G; 3] = [__v_27, __v_26, __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(2); + let __v_33: G = G::from_u64(0); + let __v_34: G = { let __values: [G; 4] = [__v_32, __v_14, __v_31, __v_33]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = G::from_u64(2); + let __v_36: G = G::from_u64(1); + let __v_37: G = G::from_u64(1); + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 4] = [__v_35, __v_18, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = G::from_u64(2); + let __v_42: G = G::from_u64(1); + let __v_43: G = G::from_u64(1); + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 4] = [__v_41, __v_20, __v_44, __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(3); + let __v_48: G = G::from_u64(0); + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_34, __v_40, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_50: G = G::from_u64(3); + let __v_51: G = G::from_u64(0); + let __v_52: G = { let __values: [G; 4] = [__v_50, __v_49, __v_46, __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 __mc_out___mc_1: [G; 1] = '__mc_1: { match __v_0.as_canonical_u64() { + 1u64 => { + match __v_2.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_263] = { let __args: [G; IN_263] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[263].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_263] = unsafe { *(result.output.as_ptr() as *const [G; OUT_263]) }; __ret } else { aiur_fn_263(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + break '__mc_1 [__v_53]; + }, + 0u64 => { + let __r_arr: [G; OUT_264] = { let __args: [G; IN_264] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[264].get_mut(&__args[..]) { 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_53: G = __r_arr[0]; + break '__mc_1 [__v_53]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + 0u64 => { + match __v_2.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_265] = { let __args: [G; IN_265] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[265].get_mut(&__args[..]) { 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_53: G = __r_arr[0]; + break '__mc_1 [__v_53]; + }, + 0u64 => { + let __r_arr: [G; OUT_266] = { let __args: [G; IN_266] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[266].get_mut(&__args[..]) { 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_53: G = __r_arr[0]; + break '__mc_1 [__v_53]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, +} + }; + let __v_53: G = __mc_out___mc_1[0]; + let __v_54: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_53, __v_10, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + match __v_55.as_canonical_u64() { + 0u64 => { + let __v_57: G = G::from_u64(0); + let __v_58: G = G::from_u64(0); + let __v_59: G = G::from_u64(0); + let __v_60: G = G::from_u64(0); + let __v_61: G = { let __values: [G; 4] = [__v_58, __v_59, __v_60, __v_60]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_369] = [__v_57, __v_61]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_57: G = G::from_u64(1); + let __v_58: G = (__v_57 - __v_2); + let __v_59: G = (__v_0 * __v_58); + match __v_59.as_canonical_u64() { + 1u64 => { + let __v_60: G = G::from_u64(0); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = G::from_u64(0); + let __v_64: G = { let __values: [G; 4] = [__v_61, __v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_369] = [__v_60, __v_64]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_60: G = G::from_u64(2); + let __v_61: G = G::from_u64(1); + let __v_62: G = G::from_u64(1); + let __v_63: G = { let __values: [G; 3] = [__v_61, __v_62, __v_62]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = G::from_u64(0); + let __v_65: G = { let __values: [G; 4] = [__v_60, __v_56, __v_63, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_66: G = G::from_u64(3); + let __v_67: G = G::from_u64(0); + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_3, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = G::from_u64(3); + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_4, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_72: G = G::from_u64(3); + let __v_73: G = G::from_u64(0); + let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_52, __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 __r_arr: [G; OUT_370] = { let __args: [G; IN_370] = [__v_2, __v_74, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[370].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_370] = unsafe { *(result.output.as_ptr() as *const [G; OUT_370]) }; __ret } else { aiur_fn_370(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __v_76: G = __r_arr[1]; + let __ret: [G; OUT_369] = [__v_75, __v_76]; + record.function_queries[369].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_59.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_370: usize = 8; +const IN_370: usize = 8; +const OUT_370: usize = 2; +fn aiur_fn_370( + inp: [G; IN_370], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_370], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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 __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_0.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_261] = { let __args: [G; IN_261] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[261].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_261] = unsafe { *(result.output.as_ptr() as *const [G; OUT_261]) }; __ret } else { aiur_fn_261(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + break '__mc_0 [__v_8]; + }, + 0u64 => { + let __r_arr: [G; OUT_262] = { let __args: [G; IN_262] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[262].get_mut(&__args[..]) { 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_8: G = __r_arr[0]; + break '__mc_0 [__v_8]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, +} + }; + let __v_8: G = __mc_out___mc_0[0]; + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_8, __v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { 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_370] = [__v_12, __v_16]; + record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_12: G = G::from_u64(2); + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_2, __v_3, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = G::from_u64(2); + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_14, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_17, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_18, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_22: G = __r_arr[0]; + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __a_val = __v_22.as_canonical_u64(); let __b_val = __v_23.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_24.as_canonical_u64() { + 1u64 => { + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = { 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_370] = [__v_25, __v_29]; + record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_25: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_21, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(2); + 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 __v_32: G = { let __values: [G; 4] = [__v_27, __v_11, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = G::from_u64(3); + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 4] = [__v_33, __v_32, __v_26, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(3); + let __v_37: G = G::from_u64(0); + let __v_38: G = { let __values: [G; 4] = [__v_36, __v_35, __v_1, __v_37]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = G::from_u64(2); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_4, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __v_41: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_38, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __ret: [G; OUT_370] = [__v_41, __v_42]; + record.function_queries[370].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_371: usize = 3; +const IN_371: usize = 3; +const OUT_371: usize = 2; +fn aiur_fn_371( + inp: [G; IN_371], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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_198] = { let __args: [G; IN_198] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(1); + let __v_5: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_4.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_6, __v_10]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __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]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 7u64 => { + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_295] = { let __args: [G; IN_295] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[295].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_295] = unsafe { *(result.output.as_ptr() as *const [G; OUT_295]) }; __ret } else { aiur_fn_295(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __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 __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; 10] = [__v_23, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = { let __values: [G; 10] = [__v_22, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __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 __v_28: G = G::from_u64(7); + 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_26, __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_371] = [__v_27, __v_31]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_298] = { let __args: [G; IN_298] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[298].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_298] = unsafe { *(result.output.as_ptr() as *const [G; OUT_298]) }; __ret } else { aiur_fn_298(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + match __v_15.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_372] = { let __args: [G; IN_372] = [__v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[372].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_372] = unsafe { *(result.output.as_ptr() as *const [G; OUT_372]) }; __ret } else { aiur_fn_372(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __ret: [G; OUT_371] = [__v_16, __v_17]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_296] = { let __args: [G; IN_296] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[296].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_296] = unsafe { *(result.output.as_ptr() as *const [G; OUT_296]) }; __ret } else { aiur_fn_296(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_297] = { let __args: [G; IN_297] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[297].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_297] = unsafe { *(result.output.as_ptr() as *const [G; OUT_297]) }; __ret } else { aiur_fn_297(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = (__v_17 + __v_19); + match __v_20.as_canonical_u64() { + 0u64 => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = { 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_371] = [__v_21, __v_25]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_373] = { let __args: [G; IN_373] = [__v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[373].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_373] = unsafe { *(result.output.as_ptr() as *const [G; OUT_373]) }; __ret } else { aiur_fn_373(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __ret: [G; OUT_371] = [__v_21, __v_22]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_12, __v_16]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_12, __v_16]; + record.function_queries[371].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_372: usize = 2; +const IN_372: usize = 2; +const OUT_372: usize = 2; +fn aiur_fn_372( + inp: [G; IN_372], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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 __r_arr: [G; OUT_299] = { let __args: [G; IN_299] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[299].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_299] = unsafe { *(result.output.as_ptr() as *const [G; OUT_299]) }; __ret } else { aiur_fn_299(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_5, __v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(2); + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 3] = [__v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_8, __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 __ret: [G; OUT_372] = [__v_9, __v_15]; + record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + 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 = { 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_372] = [__v_9, __v_13]; + record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_372] = [__v_5, __v_9]; + record.function_queries[372].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_373: usize = 2; +const IN_373: usize = 2; +const OUT_373: usize = 2; +fn aiur_fn_373( + inp: [G; IN_373], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_373], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_6, __v_10]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_376] = { let __args: [G; IN_376] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[376].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_376] = unsafe { *(result.output.as_ptr() as *const [G; OUT_376]) }; __ret } else { aiur_fn_376(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_13: G = G::from_u64(1); + let __v_14: G = G::from_u64(1); + let __v_15: G = { let __values: [G; 3] = [__v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_12, __v_5, __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 __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_17, __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_373] = [__v_18, __v_21]; + record.function_queries[373].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_374: usize = 1; +const IN_374: usize = 1; +const OUT_374: usize = 4; +fn aiur_fn_374( + inp: [G; IN_374], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_374], 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_316] = { let __args: [G; IN_316] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_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_316] = { let __args: [G; IN_316] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_316] = { let __args: [G; IN_316] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[316].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_316] = unsafe { *(result.output.as_ptr() as *const [G; OUT_316]) }; __ret } else { aiur_fn_316(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_374] = [__v_2, __v_5, __v_8, __v_11]; + record.function_queries[374].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_375: usize = 1; +const IN_375: usize = 1; +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_375], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_374] = { let __args: [G; IN_374] = [__v_0]; let __cu = true; if let Some(result) = record.function_queries[374].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __v_3: G = __r_arr[2]; + let __v_4: G = __r_arr[3]; + let __v_5: G = G::from_u64(0); + let __v_6: G = if unconstrained { Bytes2::xor(&__v_1, &__v_5) } else { bytes2_xor_value(__v_1, __v_5, record) }; + let __v_7: G = G::from_u64(0); + let __v_8: G = if unconstrained { Bytes2::xor(&__v_2, &__v_7) } else { bytes2_xor_value(__v_2, __v_7, record) }; + let __v_9: G = G::from_u64(0); + let __v_10: G = if unconstrained { Bytes2::xor(&__v_3, &__v_9) } else { bytes2_xor_value(__v_3, __v_9, record) }; + let __v_11: G = G::from_u64(0); + let __v_12: G = if unconstrained { Bytes2::xor(&__v_4, &__v_11) } else { bytes2_xor_value(__v_4, __v_11, record) }; + let __v_13: G = G::from_u64(256); + let __v_14: G = (__v_13 * __v_8); + let __v_15: G = G::from_u64(65536); + let __v_16: G = (__v_15 * __v_10); + let __v_17: G = G::from_u64(16777216); + let __v_18: G = (__v_17 * __v_12); + let __v_19: G = (__v_16 + __v_18); + let __v_20: G = (__v_14 + __v_19); + let __v_21: G = (__v_6 + __v_20); + if (__v_0 != __v_21) { + return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_21.as_canonical_u64() }); + } + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = G::from_u64(1); + let __v_29: G = { let __values: [G; 10] = [__v_27, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = { let __values: [G; 10] = [__v_22, __v_6, __v_8, __v_10, __v_12, __v_23, __v_24, __v_25, __v_26, __v_29]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_375] = [__v_30]; + record.function_queries[375].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_376: usize = 1; +const IN_376: usize = 1; +const OUT_376: usize = 1; +fn aiur_fn_376( + inp: [G; IN_376], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_376], 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_377] = { let __args: [G; IN_377] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __ret: [G; OUT_376] = [__v_2]; + record.function_queries[376].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_377: usize = 2; +const IN_377: usize = 2; +const OUT_377: usize = 1; +fn aiur_fn_377( + inp: [G; IN_377], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_377] = [__v_1]; + record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __r_arr: [G; OUT_377] = { let __args: [G; IN_377] = [__v_6, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[377].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_377] = unsafe { *(result.output.as_ptr() as *const [G; OUT_377]) }; __ret } else { aiur_fn_377(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_377] = [__v_7]; + record.function_queries[377].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_378: usize = 2; +const IN_378: usize = 2; +const OUT_378: usize = 2; +fn aiur_fn_378( + inp: [G; IN_378], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 = G::from_u64(128); + let __v_3: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_2) } else { bytes2_less_than_value(__v_0, __v_2, record) }; + match __v_3.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_378] = [__v_0, __v_1]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_4: G = G::from_u64(224); + let __v_5: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_4) } else { bytes2_less_than_value(__v_0, __v_4, record) }; + match __v_5.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_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_9: G = G::from_u64(192); + let __v_10: G = (__v_0 - __v_9); + let __v_11: G = G::from_u64(64); + let __v_12: G = (__v_10 * __v_11); + let __v_13: G = G::from_u64(128); + let __v_14: G = (__v_7 - __v_13); + let __v_15: G = (__v_12 + __v_14); + let __ret: [G; OUT_378] = [__v_15, __v_8]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __v_6: G = G::from_u64(240); + let __v_7: G = if unconstrained { Bytes2::less_than(&__v_0, &__v_6) } else { bytes2_less_than_value(__v_0, __v_6, record) }; + match __v_7.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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 => { + let __v_14: G = G::from_u64(224); + let __v_15: G = (__v_0 - __v_14); + let __v_16: G = G::from_u64(4096); + let __v_17: G = (__v_15 * __v_16); + let __v_18: G = G::from_u64(128); + let __v_19: G = (__v_9 - __v_18); + let __v_20: G = G::from_u64(64); + let __v_21: G = (__v_19 * __v_20); + let __v_22: G = G::from_u64(128); + let __v_23: G = (__v_12 - __v_22); + let __v_24: G = (__v_21 + __v_23); + let __v_25: G = (__v_17 + __v_24); + let __ret: [G; OUT_378] = [__v_25, __v_13]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_17: G = G::from_u64(240); + let __v_18: G = (__v_0 - __v_17); + let __v_19: G = G::from_u64(262144); + let __v_20: G = (__v_18 * __v_19); + let __v_21: G = G::from_u64(128); + let __v_22: G = (__v_9 - __v_21); + let __v_23: G = G::from_u64(4096); + let __v_24: G = (__v_22 * __v_23); + let __v_25: G = G::from_u64(128); + let __v_26: G = (__v_12 - __v_25); + let __v_27: G = G::from_u64(64); + let __v_28: G = (__v_26 * __v_27); + let __v_29: G = G::from_u64(128); + let __v_30: G = (__v_15 - __v_29); + let __v_31: G = (__v_28 + __v_30); + let __v_32: G = (__v_24 + __v_31); + let __v_33: G = (__v_20 + __v_32); + let __ret: [G; OUT_378] = [__v_33, __v_16]; + record.function_queries[378].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_379: usize = 2; +const IN_379: usize = 2; +const OUT_379: usize = 2; +fn aiur_fn_379( + inp: [G; IN_379], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_379], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_303] = { let __args: [G; IN_303] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[303].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_303] = unsafe { *(result.output.as_ptr() as *const [G; OUT_303]) }; __ret } else { aiur_fn_303(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_2, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_7, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_6, __v_10]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_304] = { let __args: [G; IN_304] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[304].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_304] = unsafe { *(result.output.as_ptr() as *const [G; OUT_304]) }; __ret } else { aiur_fn_304(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_6, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_10, __v_14]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_301] = { let __args: [G; IN_301] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[301].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_301] = unsafe { *(result.output.as_ptr() as *const [G; OUT_301]) }; __ret } else { aiur_fn_301(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_10, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = { 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_379] = [__v_14, __v_18]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_300] = { let __args: [G; IN_300] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[300].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_300] = unsafe { *(result.output.as_ptr() as *const [G; OUT_300]) }; __ret } else { aiur_fn_300(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_14, __v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + match __v_16.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { 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_379] = [__v_18, __v_22]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_302] = { let __args: [G; IN_302] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[302].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_302] = unsafe { *(result.output.as_ptr() as *const [G; OUT_302]) }; __ret } else { aiur_fn_302(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_18, __v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = { let __values: [G; 4] = [__v_23, __v_24, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_379] = [__v_22, __v_26]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(1); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = { let __values: [G; 3] = [__v_25, __v_24, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = G::from_u64(2); + let __v_31: G = G::from_u64(0); + let __v_32: G = { let __values: [G; 4] = [__v_30, __v_5, __v_29, __v_31]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = G::from_u64(2); + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 4] = [__v_33, __v_9, __v_29, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(2); + let __v_37: G = G::from_u64(1); + let __v_38: G = G::from_u64(1); + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = G::from_u64(0); + let __v_41: G = { let __values: [G; 4] = [__v_36, __v_13, __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 __v_43: G = G::from_u64(1); + let __v_44: G = G::from_u64(1); + let __v_45: G = { let __values: [G; 3] = [__v_43, __v_44, __v_44]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_46: G = G::from_u64(0); + let __v_47: G = { let __values: [G; 4] = [__v_42, __v_17, __v_45, __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(2); + let __v_49: G = G::from_u64(1); + let __v_50: G = G::from_u64(1); + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_52: G = G::from_u64(0); + let __v_53: G = { let __values: [G; 4] = [__v_48, __v_21, __v_51, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_54: G = G::from_u64(3); + let __v_55: G = G::from_u64(0); + let __v_56: G = { let __values: [G; 4] = [__v_54, __v_32, __v_41, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_57: G = G::from_u64(3); + let __v_58: G = G::from_u64(0); + let __v_59: G = { let __values: [G; 4] = [__v_57, __v_35, __v_41, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_0, __v_56, __v_59, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __v_61: G = G::from_u64(1); + let __v_62: G = G::from_u64(3); + let __v_63: G = G::from_u64(0); + let __v_64: G = { let __values: [G; 4] = [__v_62, __v_53, __v_60, __v_63]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_379] = [__v_61, __v_64]; + record.function_queries[379].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_380: usize = 4; +const IN_380: usize = 4; +const OUT_380: usize = 1; +fn aiur_fn_380( + inp: [G; IN_380], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_380], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __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_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_380] = [__v_1]; + record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_378] = { let __args: [G; IN_378] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[378].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_378] = unsafe { *(result.output.as_ptr() as *const [G; OUT_378]) }; __ret } else { aiur_fn_378(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __r_arr: [G; OUT_375] = { let __args: [G; IN_375] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[375].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_375] = unsafe { *(result.output.as_ptr() as *const [G; OUT_375]) }; __ret } else { aiur_fn_375(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(7); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_9, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = G::from_u64(3); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_14, __v_3, __v_13, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = G::from_u64(3); + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 4] = [__v_17, __v_2, __v_16, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_380] = { let __args: [G; IN_380] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[380].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_380] = unsafe { *(result.output.as_ptr() as *const [G; OUT_380]) }; __ret } else { aiur_fn_380(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __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_380] = [__v_23]; + record.function_queries[380].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_381: usize = 2; +const IN_381: usize = 2; +const OUT_381: usize = 1; +fn aiur_fn_381( + inp: [G; IN_381], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_381], 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() { + 7u64 => { + match __v_3.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_381] = [__v_7]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_381] = [__v_0]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + let __ret: [G; OUT_381] = [__v_0]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_381] = [__v_0]; + record.function_queries[381].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_382: usize = 3; +const IN_382: usize = 3; +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_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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + 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]; + let __v_10: G = __loaded[6]; + let __v_11: G = __loaded[7]; + let __v_12: G = __loaded[8]; + let __v_13: G = __loaded[9]; + let __v_14: G = __loaded[10]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __v_19: G = __r_arr[3]; + let __v_20: G = __r_arr[4]; + match __v_16.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 !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_21: G = __r_arr[0]; + let __v_22: G = { let __a_val = __v_21.as_canonical_u64(); let __b_val = __v_17.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_22.as_canonical_u64() { + 1u64 => { + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __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_382] = [__v_23, __v_27]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(8); + let __v_25: G = { let __values: [G; 4] = [__v_24, __v_18, __v_19, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __ret: [G; OUT_382] = [__v_27, __v_28]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + 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 = { 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_382] = [__v_21, __v_25]; + record.function_queries[382].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 __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]; + record.function_queries[382].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_383: usize = 5; +const IN_383: usize = 5; +const OUT_383: usize = 2; +fn aiur_fn_383( + inp: [G; IN_383], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_383], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_259] = { let __args: [G; IN_259] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[259].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_259] = unsafe { *(result.output.as_ptr() as *const [G; OUT_259]) }; __ret } else { aiur_fn_259(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_383] = [__v_8, __v_12]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_260] = { let __args: [G; IN_260] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[260].get_mut(&__args[..]) { 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_13: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = { let __values: [G; 4] = [__v_16, __v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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, __v_19]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(5); + let __v_17: G = { let __a_val = __v_15.as_canonical_u64(); let __b_val = __v_16.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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 __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { 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_383] = [__v_18, __v_22]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(2); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(3); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(4); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_21.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_28: G = __loaded[0]; + let __v_29: G = __loaded[1]; + let __v_30: G = __loaded[2]; + let __v_31: G = __loaded[3]; + match __v_28.as_canonical_u64() { + 4u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + match __v_32.as_canonical_u64() { + 4u64 => { + let __v_36: G = G::from_u64(8); + let __v_37: G = { let __values: [G; 4] = [__v_36, __v_0, __v_1, __v_34]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = G::from_u64(4); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 4] = [__v_38, __v_33, __v_37, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_25.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_41: G = __loaded[0]; + let __v_42: G = __loaded[1]; + let __v_43: G = __loaded[2]; + let __v_44: G = __loaded[3]; + match __v_41.as_canonical_u64() { + 4u64 => { + let __v_45: G = G::from_u64(8); + let __v_46: G = { let __values: [G; 4] = [__v_45, __v_0, __v_1, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_47: G = G::from_u64(4); + let __v_48: G = G::from_u64(0); + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_42, __v_46, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __v_51: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_50, __v_4, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __v_53: G = __r_arr[1]; + match __v_52.as_canonical_u64() { + 1u64 => { + let __v_54: G = G::from_u64(2); + 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 __v_58: G = G::from_u64(0); + let __v_59: G = { let __values: [G; 4] = [__v_54, __v_53, __v_57, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_60: G = G::from_u64(4); + let __v_61: G = G::from_u64(0); + let __v_62: G = { let __values: [G; 4] = [__v_60, __v_29, __v_59, __v_61]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_63: G = G::from_u64(2); + let __v_64: G = G::from_u64(0); + let __v_65: G = { let __values: [G; 4] = [__v_63, __v_9, __v_10, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_66: G = G::from_u64(3); + let __v_67: G = G::from_u64(0); + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_19, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = G::from_u64(3); + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 4] = [__v_69, __v_68, __v_62, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_72: G = G::from_u64(3); + let __v_73: G = G::from_u64(0); + let __v_74: G = { let __values: [G; 4] = [__v_72, __v_71, __v_40, __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(3); + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 4] = [__v_75, __v_74, __v_49, __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 __v_78: G = G::from_u64(3); + let __v_79: G = G::from_u64(0); + let __v_80: G = { let __values: [G; 4] = [__v_78, __v_77, __v_27, __v_79]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_81: G = G::from_u64(5); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_3, __v_81]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_82: G = __r_arr[0]; + let __v_83: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_80, __v_82]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __ret: [G; OUT_383] = [__v_83, __v_84]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = { let __values: [G; 4] = [__v_55, __v_56, __v_57, __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 __ret: [G; OUT_383] = [__v_54, __v_58]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_52.as_canonical_u64())); + }, + } + }, + _ => { + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = { let __values: [G; 4] = [__v_46, __v_47, __v_48, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_383] = [__v_45, __v_49]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 4] = [__v_37, __v_38, __v_39, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_383] = [__v_36, __v_40]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = { 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_383] = [__v_32, __v_36]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_13, __v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_12, __v_16]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_383] = [__v_8, __v_12]; + record.function_queries[383].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_384: usize = 2; +const IN_384: usize = 2; +const OUT_384: usize = 5; +fn aiur_fn_384( + inp: [G; IN_384], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_384], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __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() { + 4u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 + __v_6); + let __r_arr: [G; OUT_384] = { let __args: [G; IN_384] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[384].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_384] = unsafe { *(result.output.as_ptr() as *const [G; OUT_384]) }; __ret } else { aiur_fn_384(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __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_384] = [__v_8, __v_9, __v_10, __v_11, __v_12]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_10: G = { let __a_val = __v_7.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_10.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_1 - __v_12); + let __v_14: G = (__v_13 - __v_7); + let __ret: [G; OUT_384] = [__v_11, __v_1, __v_3, __v_4, __v_14]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_384] = [__v_11, __v_12, __v_13, __v_14, __v_15]; + record.function_queries[384].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(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_384] = [__v_10, __v_11, __v_12, __v_13, __v_14]; + record.function_queries[384].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 __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_384] = [__v_6, __v_7, __v_8, __v_9, __v_10]; + record.function_queries[384].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_385: usize = 1; +const IN_385: usize = 1; +const OUT_385: usize = 1; +fn aiur_fn_385( + inp: [G; IN_385], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_385], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __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_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_2 + __v_5); + let __ret: [G; OUT_385] = [__v_6]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_385] = [__v_5]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_385] = [__v_5]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_385] = [__v_5]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_385] = [__v_7]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_385] = [__v_8]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_385] = [__v_8]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_386] = { let __args: [G; IN_386] = [__v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[386].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_386] = unsafe { *(result.output.as_ptr() as *const [G; OUT_386]) }; __ret } else { aiur_fn_386(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_385] = [__v_5]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_385] = [__v_5]; + record.function_queries[385].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_386: usize = 3; +const IN_386: usize = 3; +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_386], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_388] = { let __args: [G; IN_388] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[388].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_388] = unsafe { *(result.output.as_ptr() as *const [G; OUT_388]) }; __ret } else { aiur_fn_388(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_386] = [__v_8]; + record.function_queries[386].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_387: usize = 2; +const IN_387: usize = 2; +const OUT_387: usize = 1; +fn aiur_fn_387( + inp: [G; IN_387], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_387], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = { 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_387] = [__v_1]; + record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_387] = [__v_0]; + record.function_queries[387].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_388: usize = 1; +const IN_388: usize = 1; +const OUT_388: usize = 1; +fn aiur_fn_388( + inp: [G; IN_388], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_388], 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_388] = [__v_1]; + record.function_queries[388].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_388] = [__v_2]; + record.function_queries[388].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +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_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 = { 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_389] = [__v_0]; + record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_389] = [__v_1]; + record.function_queries[389].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_390: usize = 2; +const IN_390: usize = 2; +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_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_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_2: G = __r_arr[0]; + 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 !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_3: G = __r_arr[0]; + let __r_arr: [G; OUT_391] = { let __args: [G; IN_391] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_390] = [__v_4]; + record.function_queries[390].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_391: usize = 3; +const IN_391: usize = 3; +const OUT_391: usize = 1; +fn aiur_fn_391( + inp: [G; IN_391], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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 = G::from_u64(0); + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_2, __v_3, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_389] = { let __args: [G; IN_389] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[389].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_389] = unsafe { *(result.output.as_ptr() as *const [G; OUT_389]) }; __ret } else { aiur_fn_389(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = { let __a_val = __v_2.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_391] = { let __args: [G; IN_391] = [__v_0, __v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[391].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_391] = unsafe { *(result.output.as_ptr() as *const [G; OUT_391]) }; __ret } else { aiur_fn_391(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_391] = [__v_7]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_391] = [__v_2]; + record.function_queries[391].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_392: usize = 4; +const IN_392: usize = 4; +const OUT_392: usize = 1; +fn aiur_fn_392( + inp: [G; IN_392], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_392], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = { 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_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_392] = [__v_3]; + record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_2 + __v_5); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = (__v_6 + __v_8); + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_2 + __v_10); + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_3, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_392] = { let __args: [G; IN_392] = [__v_0, __v_1, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[392].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_392] = unsafe { *(result.output.as_ptr() as *const [G; OUT_392]) }; __ret } else { aiur_fn_392(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_392] = [__v_13]; + record.function_queries[392].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_393: usize = 2; +const IN_393: usize = 2; +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_393], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_393] = [__v_4]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !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_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_393] = [__v_0]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_390] = { let __args: [G; IN_390] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[390].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_390] = unsafe { *(result.output.as_ptr() as *const [G; OUT_390]) }; __ret } else { aiur_fn_390(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_393] = [__v_5]; + record.function_queries[393].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_394: usize = 3; +const IN_394: usize = 3; +const OUT_394: usize = 1; +fn aiur_fn_394( + inp: [G; IN_394], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_394], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_394] = [__v_0]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_394] = [__v_0]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_395] = { let __args: [G; IN_395] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[395].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_395] = unsafe { *(result.output.as_ptr() as *const [G; OUT_395]) }; __ret } else { aiur_fn_395(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_394] = [__v_5]; + record.function_queries[394].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_395: usize = 3; +const IN_395: usize = 3; +const OUT_395: usize = 1; +fn aiur_fn_395( + inp: [G; IN_395], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_395], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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 __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_395] = [__v_0]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = (__v_4 + __v_1); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_395] = [__v_11]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + 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_395] = [__v_9]; + record.function_queries[395].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_395] = [__v_9]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_7: G = G::from_u64(3); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_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_395] = [__v_11]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_7: G = G::from_u64(4); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_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_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_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_395] = [__v_13]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_7: G = G::from_u64(5); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_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_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_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_395] = [__v_13]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_7: G = G::from_u64(6); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_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_394] = { let __args: [G; IN_394] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_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_395] = [__v_13]; + record.function_queries[395].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_395] = [__v_9]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __v_7: G = G::from_u64(8); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_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_395] = [__v_9]; + record.function_queries[395].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_396: usize = 3; +const IN_396: usize = 3; +const OUT_396: usize = 1; +fn aiur_fn_396( + inp: [G; IN_396], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_396], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_396] = [__v_0]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_397] = { let __args: [G; IN_397] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[397].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_397] = unsafe { *(result.output.as_ptr() as *const [G; OUT_397]) }; __ret } else { aiur_fn_397(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_396] = [__v_5]; + record.function_queries[396].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_397: usize = 3; +const IN_397: usize = 3; +const OUT_397: usize = 1; +fn aiur_fn_397( + inp: [G; IN_397], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_397], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __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_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_7: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_397] = [__v_0]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = (__v_4 - __v_2); + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_1, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_397] = [__v_10]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_4 - __v_10); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_9, __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_397] = [__v_13]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + 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_397] = [__v_9]; + record.function_queries[397].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_397] = [__v_9]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_7: G = G::from_u64(3); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(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_397] = [__v_11]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_7: G = G::from_u64(4); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_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_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_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_397] = [__v_13]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_7: G = G::from_u64(5); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_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_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_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_397] = [__v_13]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_7: G = G::from_u64(6); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_2 + __v_10); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_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_397] = [__v_13]; + record.function_queries[397].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_397] = [__v_9]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __v_7: G = G::from_u64(8); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_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_397] = [__v_9]; + record.function_queries[397].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_398: usize = 3; +const IN_398: usize = 3; +const OUT_398: usize = 1; +fn aiur_fn_398( + inp: [G; IN_398], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_398], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = { let __a_val = __v_2.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_398] = [__v_0]; + record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_400] = { let __args: [G; IN_400] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[400].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_400] = unsafe { *(result.output.as_ptr() as *const [G; OUT_400]) }; __ret } else { aiur_fn_400(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_398] = [__v_5]; + record.function_queries[398].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +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_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 __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_2.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = { let __values: [G; 4] = [__v_4, __v_0, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_6]; + record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + 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 !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_4: G = __r_arr[0]; + let __v_5: G = (__v_2 + __v_4); + 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 __v_7: G = (__v_0 - __v_2); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_8, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_399] = [__v_10]; + record.function_queries[399].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = (__v_0 - __v_4); + 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_399] = [__v_10]; + record.function_queries[399].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_400: usize = 3; +const IN_400: usize = 3; +const OUT_400: usize = 1; +fn aiur_fn_400( + inp: [G; IN_400], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_400], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __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_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_399] = { let __args: [G; IN_399] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[399].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_399] = unsafe { *(result.output.as_ptr() as *const [G; OUT_399]) }; __ret } else { aiur_fn_399(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_400] = [__v_7]; + record.function_queries[400].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_400] = [__v_9]; + record.function_queries[400].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_400] = [__v_9]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_7: G = G::from_u64(3); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_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_400] = [__v_11]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_7: G = G::from_u64(4); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_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_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_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_400] = [__v_13]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_7: G = G::from_u64(5); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_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_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_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_400] = [__v_13]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_7: G = G::from_u64(6); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_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_398] = { let __args: [G; IN_398] = [__v_6, __v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_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_400] = [__v_13]; + record.function_queries[400].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_400] = [__v_9]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __v_7: G = G::from_u64(8); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_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_400] = [__v_9]; + record.function_queries[400].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_401: usize = 2; +const IN_401: usize = 2; +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_401], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_401] = [__v_0]; + record.function_queries[401].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_401] = { let __args: [G; IN_401] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_401] = [__v_8]; + record.function_queries[401].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_402: usize = 3; +const IN_402: usize = 3; +const OUT_402: usize = 3; +fn aiur_fn_402( + inp: [G; IN_402], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __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_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 4u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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 __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_402] = { let __args: [G; IN_402] = [__v_5, __v_9, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + let __ret: [G; OUT_402] = [__v_12, __v_13, __v_14]; + record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __ret: [G; OUT_402] = [__v_0, __v_2, __v_1]; + record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + let __ret: [G; OUT_402] = [__v_0, __v_2, __v_1]; + record.function_queries[402].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_403: usize = 5; +const IN_403: usize = 5; +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_403], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + 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_402] = { let __args: [G; IN_402] = [__v_1, __v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_403] = [__v_12]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_15, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_403] = [__v_16]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_8, __v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_13, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_403] = [__v_14]; + record.function_queries[403].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_404: usize = 5; +const IN_404: usize = 5; +const OUT_404: usize = 1; +fn aiur_fn_404( + inp: [G; IN_404], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_404], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_9, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_404] = [__v_12]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_403] = { let __args: [G; IN_403] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[403].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_403] = unsafe { *(result.output.as_ptr() as *const [G; OUT_403]) }; __ret } else { aiur_fn_403(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_404] = [__v_9]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_408] = { let __args: [G; IN_408] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[408].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_408] = unsafe { *(result.output.as_ptr() as *const [G; OUT_408]) }; __ret } else { aiur_fn_408(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_404] = [__v_9]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_404] = [__v_11]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_405] = { let __args: [G; IN_405] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[405].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_405] = unsafe { *(result.output.as_ptr() as *const [G; OUT_405]) }; __ret } else { aiur_fn_405(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_404] = [__v_9]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_404] = [__v_9]; + record.function_queries[404].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_405: usize = 7; +const IN_405: usize = 7; +const OUT_405: usize = 1; +fn aiur_fn_405( + inp: [G; IN_405], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_405], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_2, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + 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 !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 __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_405] = [__v_12]; + record.function_queries[405].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_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_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + match __v_12.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + let __v_21: G = __loaded[4]; + let __v_22: G = __loaded[5]; + let __v_23: G = __loaded[6]; + let __v_24: G = __loaded[7]; + let __v_25: G = __loaded[8]; + let __v_26: G = __loaded[9]; + let __v_27: G = __loaded[10]; + match __v_17.as_canonical_u64() { + 6u64 => { + let __v_28: G = (__v_22 + __v_1); + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_29, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_405] = [__v_30]; + record.function_queries[405].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_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 __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_405] = [__v_30]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_16: G = G::from_u64(8); + let __v_17: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __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 __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __ret: [G; OUT_405] = [__v_18]; + record.function_queries[405].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_406: usize = 5; +const IN_406: usize = 5; +const OUT_406: usize = 2; +fn aiur_fn_406( + inp: [G; IN_406], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_406], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __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_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_286] = { let __args: [G; IN_286] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[286].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_286] = unsafe { *(result.output.as_ptr() as *const [G; OUT_286]) }; __ret } else { aiur_fn_286(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_285] = { let __args: [G; IN_285] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[285].get_mut(&__args[..]) { 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]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_9, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = (__v_13 + __v_15); + let __v_17: G = (__v_11 + __v_16); + match __v_17.as_canonical_u64() { + 0u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = { 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_406] = [__v_18, __v_22]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + 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 !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]; + match __v_18.as_canonical_u64() { + 2u64 => { + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_20, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_23, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_24, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + match __v_25.as_canonical_u64() { + 0u64 => { + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = { 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_406] = [__v_27, __v_31]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_315] = { let __args: [G; IN_315] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[315].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_315] = unsafe { *(result.output.as_ptr() as *const [G; OUT_315]) }; __ret } else { aiur_fn_315(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = (__v_16 * __v_29); + let __v_31: G = (__v_27 + __v_30); + match __v_31.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_21, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + match __v_32.as_canonical_u64() { + 1u64 => { + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = { let __values: [G; 4] = [__v_35, __v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_406] = [__v_34, __v_38]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_34: G = G::from_u64(1); + let __v_35: G = G::from_u64(3); + let __v_36: G = G::from_u64(3); + let __v_37: G = G::from_u64(0); + let __v_38: G = { let __values: [G; 4] = [__v_36, __v_0, __v_21, __v_37]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = G::from_u64(0); + let __v_41: G = { let __values: [G; 4] = [__v_35, __v_38, __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 __ret: [G; OUT_406] = [__v_34, __v_41]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_32.as_canonical_u64())); + }, + } + }, + _ => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = { 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_406] = [__v_32, __v_36]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + _ => { + 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 = { 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_406] = [__v_19, __v_23]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + 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 = { 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_406] = [__v_9, __v_13]; + record.function_queries[406].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_407: usize = 7; +const IN_407: usize = 7; +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_407], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_344] = { let __args: [G; IN_344] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[344].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_344] = unsafe { *(result.output.as_ptr() as *const [G; OUT_344]) }; __ret } else { aiur_fn_344(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_9: G = G::from_u64(1); + let __ret: [G; OUT_407] = [__v_9, __v_8]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_371] = { let __args: [G; IN_371] = [__v_0, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[371].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_371] = unsafe { *(result.output.as_ptr() as *const [G; OUT_371]) }; __ret } else { aiur_fn_371(__args, record, io_buffer, __cu)? } }; + let __v_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(1); + let __ret: [G; OUT_407] = [__v_11, __v_10]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_353] = { let __args: [G; IN_353] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[353].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_353] = unsafe { *(result.output.as_ptr() as *const [G; OUT_353]) }; __ret } else { aiur_fn_353(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(1); + let __ret: [G; OUT_407] = [__v_13, __v_12]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_355] = { let __args: [G; IN_355] = [__v_0, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[355].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_355] = unsafe { *(result.output.as_ptr() as *const [G; OUT_355]) }; __ret } else { aiur_fn_355(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_407] = [__v_15, __v_14]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_362] = { let __args: [G; IN_362] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[362].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_362] = unsafe { *(result.output.as_ptr() as *const [G; OUT_362]) }; __ret } else { aiur_fn_362(__args, record, io_buffer, __cu)? } }; + let __v_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_407] = [__v_17, __v_16]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_17, __v_21]; + record.function_queries[407].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_408: usize = 7; +const IN_408: usize = 7; +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_408], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_3, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_22]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_22]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_12, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_22]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_22]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + break '__mc_0 [__v_21, __v_22]; + }, + _ => { + 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 = { 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 } }; + break '__mc_0 [__v_21, __v_25]; + }, +} + }; + let __v_21: G = __mc_out___mc_0[0]; + let __v_22: G = __mc_out___mc_0[1]; + match __v_21.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_23]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + match __v_23.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_24, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_25]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_406] = { let __args: [G; IN_406] = [__v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[406].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_406] = unsafe { *(result.output.as_ptr() as *const [G; OUT_406]) }; __ret } else { aiur_fn_406(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + match __v_25.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_408] = [__v_26]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_12, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_27, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_28]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + 2u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_25]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_408] = [__v_25]; + record.function_queries[408].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_409: usize = 4; +const IN_409: usize = 4; +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_409], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_409] = [__v_0]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_409] = [__v_0]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __ret: [G; OUT_409] = [__v_0]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __ret: [G; OUT_409] = [__v_0]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_409] = [__v_0]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_410] = { let __args: [G; IN_410] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[410].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_410] = unsafe { *(result.output.as_ptr() as *const [G; OUT_410]) }; __ret } else { aiur_fn_410(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_409] = [__v_10]; + record.function_queries[409].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_410: usize = 4; +const IN_410: usize = 4; +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_410], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_4, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_410] = [__v_6]; + record.function_queries[410].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_411: usize = 5; +const IN_411: usize = 5; +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_411], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_9, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_411] = [__v_12]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_412] = { let __args: [G; IN_412] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[412].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_412] = unsafe { *(result.output.as_ptr() as *const [G; OUT_412]) }; __ret } else { aiur_fn_412(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_411] = [__v_9]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_414] = { let __args: [G; IN_414] = [__v_6, __v_7, __v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[414].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_414] = unsafe { *(result.output.as_ptr() as *const [G; OUT_414]) }; __ret } else { aiur_fn_414(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_411] = [__v_9]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_411] = [__v_11]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_413] = { let __args: [G; IN_413] = [__v_6, __v_7, __v_8, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[413].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_413] = unsafe { *(result.output.as_ptr() as *const [G; OUT_413]) }; __ret } else { aiur_fn_413(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_411] = [__v_9]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_411] = [__v_9]; + record.function_queries[411].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_412: usize = 5; +const IN_412: usize = 5; +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_412], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + 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_402] = { let __args: [G; IN_402] = [__v_1, __v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[402].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_402] = unsafe { *(result.output.as_ptr() as *const [G; OUT_402]) }; __ret } else { aiur_fn_402(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_412] = [__v_12]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_15, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_412] = [__v_16]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_8, __v_9, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_13, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_412] = [__v_14]; + record.function_queries[412].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_413: usize = 7; +const IN_413: usize = 7; +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_413], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_2, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + 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 !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 __r_arr: [G; OUT_383] = { let __args: [G; IN_383] = [__v_0, __v_1, __v_8, __v_9, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[383].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_383] = unsafe { *(result.output.as_ptr() as *const [G; OUT_383]) }; __ret } else { aiur_fn_383(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_11, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_413] = [__v_12]; + record.function_queries[413].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_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_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + match __v_12.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + let __v_21: G = __loaded[4]; + let __v_22: G = __loaded[5]; + let __v_23: G = __loaded[6]; + let __v_24: G = __loaded[7]; + let __v_25: G = __loaded[8]; + let __v_26: G = __loaded[9]; + let __v_27: G = __loaded[10]; + match __v_17.as_canonical_u64() { + 6u64 => { + let __v_28: G = (__v_22 + __v_1); + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_9, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_411] = { let __args: [G; IN_411] = [__v_29, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[411].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_411] = unsafe { *(result.output.as_ptr() as *const [G; OUT_411]) }; __ret } else { aiur_fn_411(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_413] = [__v_30]; + record.function_queries[413].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_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 __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_413] = [__v_30]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_16: G = G::from_u64(8); + let __v_17: G = { let __values: [G; 4] = [__v_16, __v_0, __v_1, __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 __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __ret: [G; OUT_413] = [__v_18]; + record.function_queries[413].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_414: usize = 7; +const IN_414: usize = 7; +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_414], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_417] = { let __args: [G; IN_417] = [__v_1, __v_3, __v_10, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[417].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_417] = unsafe { *(result.output.as_ptr() as *const [G; OUT_417]) }; __ret } else { aiur_fn_417(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_22]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_22]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_425] = { let __args: [G; IN_425] = [__v_12, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[425].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_425] = unsafe { *(result.output.as_ptr() as *const [G; OUT_425]) }; __ret } else { aiur_fn_425(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_21, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_22]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_22]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_343] = { let __args: [G; IN_343] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[343].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_343] = unsafe { *(result.output.as_ptr() as *const [G; OUT_343]) }; __ret } else { aiur_fn_343(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_407] = { let __args: [G; IN_407] = [__v_7, __v_0, __v_1, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[407].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_407] = unsafe { *(result.output.as_ptr() as *const [G; OUT_407]) }; __ret } else { aiur_fn_407(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + break '__mc_0 [__v_21, __v_22]; + }, + _ => { + 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 = { 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 } }; + break '__mc_0 [__v_21, __v_25]; + }, +} + }; + let __v_21: G = __mc_out___mc_0[0]; + let __v_22: G = __mc_out___mc_0[1]; + match __v_21.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_22, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_23]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_382] = { let __args: [G; IN_382] = [__v_0, __v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[382].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_382] = unsafe { *(result.output.as_ptr() as *const [G; OUT_382]) }; __ret } else { aiur_fn_382(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + match __v_23.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_24, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_25]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_414] = [__v_25]; + record.function_queries[414].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_23.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_415: usize = 4; +const IN_415: usize = 4; +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_415], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __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]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_415] = [__v_0]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_415] = [__v_0]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __ret: [G; OUT_415] = [__v_0]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __ret: [G; OUT_415] = [__v_0]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_415] = [__v_0]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_416] = { let __args: [G; IN_416] = [__v_0, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[416].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_416] = unsafe { *(result.output.as_ptr() as *const [G; OUT_416]) }; __ret } else { aiur_fn_416(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_415] = [__v_10]; + record.function_queries[415].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_416: usize = 4; +const IN_416: usize = 4; +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_416], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __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_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __r_arr: [G; OUT_404] = { let __args: [G; IN_404] = [__v_4, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[404].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_404] = unsafe { *(result.output.as_ptr() as *const [G; OUT_404]) }; __ret } else { aiur_fn_404(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_416] = [__v_6]; + record.function_queries[416].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_417: usize = 12; +const IN_417: usize = 12; +const OUT_417: usize = 2; +fn aiur_fn_417( + inp: [G; IN_417], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_417], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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 = (__v_6 + __v_4); + let __v_13: G = (__v_5 + __v_12); + let __v_14: G = (__v_3 + __v_13); + 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 !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_15: G = __r_arr[0]; + let __v_16: G = { let __a_val = __v_14.as_canonical_u64(); let __b_val = __v_15.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_16.as_canonical_u64() { + 0u64 => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = { let __values: [G; 4] = [__v_18, __v_19, __v_20, __v_20]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_417] = [__v_17, __v_21]; + record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !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_17: G = __r_arr[0]; + let __v_18: G = (__v_17 - __v_2); + match __v_18.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_421] = { let __args: [G; IN_421] = [__v_0, __v_1, __v_3, __v_5, __v_6, __v_14, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[421].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_421] = unsafe { *(result.output.as_ptr() as *const [G; OUT_421]) }; __ret } else { aiur_fn_421(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __ret: [G; OUT_417] = [__v_19, __v_20]; + record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + 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 = { 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_417] = [__v_19, __v_23]; + record.function_queries[417].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }) +} + +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_418], 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() { + 7u64 => { + let __ret: [G; OUT_418] = [__v_0]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_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 }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_419] = { let __args: [G; IN_419] = [__v_6, __v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[419].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_419] = unsafe { *(result.output.as_ptr() as *const [G; OUT_419]) }; __ret } else { aiur_fn_419(__args, record, io_buffer, __cu)? } }; + let __v_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 __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_418] = [__v_0]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_420] = { let __args: [G; IN_420] = [__v_13, __v_15, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[420].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_420] = unsafe { *(result.output.as_ptr() as *const [G; OUT_420]) }; __ret } else { aiur_fn_420(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_418] = [__v_17]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + let __ret: [G; OUT_418] = [__v_0]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __ret: [G; OUT_418] = [__v_0]; + record.function_queries[418].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_419: usize = 3; +const IN_419: usize = 3; +const OUT_419: usize = 3; +fn aiur_fn_419( + inp: [G; IN_419], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __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_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + match __v_3.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 10] = [__v_11, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_419] = [__v_10, __v_0, __v_13]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 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 !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 = G::from_u64(2); + let __v_12: G = (__v_10 - __v_11); + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(1); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + match __v_17.as_canonical_u64() { + 7u64 => { + match __v_18.as_canonical_u64() { + 0u64 => { + let __v_21: G = G::from_u64(1); + let __ret: [G; OUT_419] = [__v_21, __v_14, __v_19]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_419] = [__v_21, __v_0, __v_24]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_419] = [__v_21, __v_0, __v_24]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 10] = [__v_14, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_419] = [__v_13, __v_0, __v_16]; + record.function_queries[419].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 10] = [__v_8, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_419] = [__v_7, __v_0, __v_10]; + record.function_queries[419].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_420], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_3, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(3); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_7, __v_0, __v_0, __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_420] = [__v_9]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + 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(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 __v_19: G = { let __values: [G; 10] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __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 __r_arr: [G; OUT_313] = { let __args: [G; IN_313] = [__v_1, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[313].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_313] = unsafe { *(result.output.as_ptr() as *const [G; OUT_313]) }; __ret } else { aiur_fn_313(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(2); + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(1); + let __v_25: G = { let __values: [G; 3] = [__v_23, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_22, __v_6, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + match __v_28.as_canonical_u64() { + 1u64 => { + let __v_29: G = G::from_u64(3); + let __v_30: G = G::from_u64(0); + let __v_31: G = { let __values: [G; 4] = [__v_29, __v_27, __v_0, __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_420] = [__v_31]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_29, __v_2, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_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(3); + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 4] = [__v_33, __v_27, __v_0, __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_420] = [__v_35]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_33: G = G::from_u64(2); + 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 __v_37: G = G::from_u64(0); + let __v_38: G = { let __values: [G; 4] = [__v_33, __v_32, __v_36, __v_37]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = G::from_u64(7); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = { let __values: [G; 4] = [__v_39, __v_40, __v_21, __v_41]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = G::from_u64(3); + let __v_44: G = G::from_u64(3); + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 4] = [__v_44, __v_38, __v_0, __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(0); + let __v_48: G = { let __values: [G; 4] = [__v_43, __v_46, __v_42, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = G::from_u64(3); + let __v_50: G = G::from_u64(0); + let __v_51: G = { let __values: [G; 4] = [__v_49, __v_27, __v_48, __v_50]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_420] = [__v_51]; + record.function_queries[420].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_31.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_421: usize = 11; +const IN_421: usize = 11; +const OUT_421: usize = 2; +fn aiur_fn_421( + inp: [G; IN_421], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_421], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __r_arr: [G; OUT_422] = { let __args: [G; IN_422] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[422].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_422] = unsafe { *(result.output.as_ptr() as *const [G; OUT_422]) }; __ret } else { aiur_fn_422(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(1); + let __ret: [G; OUT_421] = [__v_13, __v_12]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_7.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_430] = { let __args: [G; IN_430] = [__v_13, __v_2, __v_6, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[430].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_430] = unsafe { *(result.output.as_ptr() as *const [G; OUT_430]) }; __ret } else { aiur_fn_430(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + match __v_14.as_canonical_u64() { + 1u64 => { + break '__mc_0 [__v_15]; + }, + 0u64 => { + break '__mc_0 [__v_13]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + 0u64 => { + break '__mc_0 [__v_13]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, +} + }; + let __v_14: G = __mc_out___mc_0[0]; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_14, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_15, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_418] = { let __args: [G; IN_418] = [__v_16, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[418].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_418] = unsafe { *(result.output.as_ptr() as *const [G; OUT_418]) }; __ret } else { aiur_fn_418(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_339] = { let __args: [G; IN_339] = [__v_17, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[339].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_339] = unsafe { *(result.output.as_ptr() as *const [G; OUT_339]) }; __ret } else { aiur_fn_339(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_381] = { let __args: [G; IN_381] = [__v_18, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[381].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_381] = unsafe { *(result.output.as_ptr() as *const [G; OUT_381]) }; __ret } else { aiur_fn_381(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_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 }; + let __v_22: G = __loaded[0]; + let __v_23: G = __loaded[1]; + let __v_24: G = __loaded[2]; + let __v_25: G = __loaded[3]; + match __v_22.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_9, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_27: G = __loaded[0]; + let __v_28: G = __loaded[1]; + let __v_29: G = __loaded[2]; + let __v_30: G = __loaded[3]; + let __v_31: G = __loaded[4]; + let __v_32: G = __loaded[5]; + let __v_33: G = __loaded[6]; + let __v_34: G = __loaded[7]; + let __v_35: G = __loaded[8]; + let __v_36: G = __loaded[9]; + let __v_37: G = __loaded[10]; + match __v_27.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = { let __a_val = __v_31.as_canonical_u64(); let __b_val = __v_38.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_39.as_canonical_u64() { + 0u64 => { + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_421] = [__v_40, __v_44]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_40: G = __r_arr[0]; + let __v_41: G = { let __a_val = __v_40.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_41.as_canonical_u64() { + 1u64 => { + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 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_421] = [__v_42, __v_46]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_6, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __v_43: G = __r_arr[1]; + let __v_44: G = __r_arr[2]; + match __v_42.as_canonical_u64() { + _ => { + let __v_45: G = (__v_3 + __v_4); + let __v_46: G = (__v_2 + __v_45); + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_1, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = (__v_40 - __v_33); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_21, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(1); + let __v_51: G = (__v_5 + __v_50); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_1, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_44, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_53, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_54, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_55, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = G::from_u64(1); + let __ret: [G; OUT_421] = [__v_57, __v_56]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_41.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_39.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_0, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __ret: [G; OUT_421] = [__v_38, __v_39]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_424] = { let __args: [G; IN_424] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_0, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[424].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_424] = unsafe { *(result.output.as_ptr() as *const [G; OUT_424]) }; __ret } else { aiur_fn_424(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __ret: [G; OUT_421] = [__v_26, __v_27]; + record.function_queries[421].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_422: usize = 8; +const IN_422: usize = 8; +const OUT_422: usize = 2; +fn aiur_fn_422( + inp: [G; IN_422], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = G::from_u64(2); + let __v_9: G = { let __a_val = __v_3.as_canonical_u64(); let __b_val = __v_8.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 4] = [__v_11, __v_12, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_422] = [__v_10, __v_14]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_10, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_11, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = { 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_422] = [__v_14, __v_18]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_14: G = (__v_1 + __v_2); + let __v_15: G = G::from_u64(1); + let __v_16: G = (__v_14 + __v_15); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_17, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_423] = { let __args: [G; IN_423] = [__v_18, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[423].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_423] = unsafe { *(result.output.as_ptr() as *const [G; OUT_423]) }; __ret } else { aiur_fn_423(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + match __v_19.as_canonical_u64() { + 0u64 => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_422] = [__v_20, __v_24]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_20, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + let __v_23: G = (__v_4 + __v_22); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_340] = { let __args: [G; IN_340] = [__v_21, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[340].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_340] = unsafe { *(result.output.as_ptr() as *const [G; OUT_340]) }; __ret } else { aiur_fn_340(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + match __v_25.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + match __v_27.as_canonical_u64() { + 1u64 => { + let __v_28: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_422] = [__v_28, __v_29]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = G::from_u64(0); + let __r_arr: [G; OUT_337] = { let __args: [G; IN_337] = [__v_28, __v_7, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[337].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_337] = unsafe { *(result.output.as_ptr() as *const [G; OUT_337]) }; __ret } else { aiur_fn_337(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + match __v_30.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = { 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_422] = [__v_32, __v_36]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_32: G = G::from_u64(2); + let __v_33: G = G::from_u64(1); + let __v_34: G = G::from_u64(1); + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(0); + let __v_37: G = { let __values: [G; 4] = [__v_32, __v_31, __v_35, __v_36]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_38: G = G::from_u64(3); + let __v_39: G = G::from_u64(3); + let __v_40: G = G::from_u64(0); + let __v_41: G = { let __values: [G; 4] = [__v_39, __v_37, __v_21, __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 __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 4] = [__v_38, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_45: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_44, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __ret: [G; OUT_422] = [__v_45, __v_46]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_30.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64())); + }, + } + }, + 1u64 => { + let __v_27: G = G::from_u64(1); + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_26, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_29, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_422] = [__v_27, __v_30]; + record.function_queries[422].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_19.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +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_423], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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() { + 4u64 => { + 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_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 4u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_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 }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + match __v_12.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + match __v_18.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(0); + let __ret: [G; OUT_423] = [__v_19]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(1); + let __v_21: G = (__v_19 - __v_20); + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_24: G = __loaded[0]; + let __v_25: G = __loaded[1]; + let __v_26: G = __loaded[2]; + let __v_27: G = __loaded[3]; + match __v_24.as_canonical_u64() { + 0u64 => { + let __v_28: G = G::from_bool((__v_25 == G::ZERO)); + let __ret: [G; OUT_423] = [__v_28]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_28: G = G::from_u64(0); + let __ret: [G; OUT_423] = [__v_28]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_22: G = G::from_u64(0); + let __ret: [G; OUT_423] = [__v_22]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }, + _ => { + let __v_16: G = G::from_u64(0); + let __ret: [G; OUT_423] = [__v_16]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_423] = [__v_10]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_423] = [__v_6]; + record.function_queries[423].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_424: usize = 10; +const IN_424: usize = 10; +const OUT_424: usize = 2; +fn aiur_fn_424( + inp: [G; IN_424], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_730] = { let __args: [G; IN_730] = [__v_5, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[730].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_730] = unsafe { *(result.output.as_ptr() as *const [G; OUT_730]) }; __ret } else { aiur_fn_730(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __v_14: G = __r_arr[2]; + match __v_12.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_15.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + let __v_19: G = __loaded[3]; + let __v_20: G = __loaded[4]; + let __v_21: G = __loaded[5]; + let __v_22: G = __loaded[6]; + let __v_23: G = __loaded[7]; + let __v_24: G = __loaded[8]; + let __v_25: G = __loaded[9]; + let __v_26: G = __loaded[10]; + match __v_16.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_27.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_28: G = __loaded[0]; + let __v_29: G = __loaded[1]; + let __v_30: G = __loaded[2]; + let __v_31: G = __loaded[3]; + let __v_32: G = __loaded[4]; + let __v_33: G = __loaded[5]; + let __v_34: G = __loaded[6]; + let __v_35: G = __loaded[7]; + let __v_36: G = __loaded[8]; + let __v_37: G = __loaded[9]; + let __v_38: G = __loaded[10]; + match __v_28.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_39.as_canonical_u64() { + 1u64 => { + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_34.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_40, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_41, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + match __v_42.as_canonical_u64() { + 1u64 => { + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = { let __values: [G; 4] = [__v_44, __v_45, __v_46, __v_46]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_424] = [__v_43, __v_47]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_14, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = (__v_1 + __v_2); + let __v_45: G = (__v_44 + __v_3); + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_0, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_43, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_47, __v_19, __v_40, __v_13, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(1); + let __v_51: G = (__v_4 + __v_50); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_49, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = G::from_u64(1); + let __ret: [G; OUT_424] = [__v_54, __v_53]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_42.as_canonical_u64())); + }, + } + }, + _ => { + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_424] = [__v_40, __v_44]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_424] = [__v_40, __v_44]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 4] = [__v_41, __v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_424] = [__v_40, __v_44]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_424] = [__v_11, __v_15]; + record.function_queries[424].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_425: usize = 5; +const IN_425: usize = 5; +const OUT_425: usize = 2; +fn aiur_fn_425( + inp: [G; IN_425], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + match __v_0.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_426] = { let __args: [G; IN_426] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[426].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_426] = unsafe { *(result.output.as_ptr() as *const [G; OUT_426]) }; __ret } else { aiur_fn_426(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __ret: [G; OUT_425] = [__v_5, __v_6]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_427] = { let __args: [G; IN_427] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[427].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_427] = unsafe { *(result.output.as_ptr() as *const [G; OUT_427]) }; __ret } else { aiur_fn_427(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __ret: [G; OUT_425] = [__v_5, __v_6]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_425] = [__v_5, __v_9]; + record.function_queries[425].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_426: usize = 4; +const IN_426: usize = 4; +const OUT_426: usize = 2; +fn aiur_fn_426( + inp: [G; IN_426], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_426], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !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_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(6); + let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_426] = [__v_7, __v_11]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(3); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(5); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(6); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(3); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_15, __v_8, __v_12, __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 __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(1); + let __ret: [G; OUT_426] = [__v_19, __v_18]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = { 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_426] = [__v_13, __v_17]; + record.function_queries[426].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_427: usize = 4; +const IN_427: usize = 4; +const OUT_427: usize = 2; +fn aiur_fn_427( + inp: [G; IN_427], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !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_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(5); + let __v_6: G = { let __a_val = __v_4.as_canonical_u64(); let __b_val = __v_5.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_8, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_427] = [__v_7, __v_11]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(3); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(4); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_428] = { let __args: [G; IN_428] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[428].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_428] = unsafe { *(result.output.as_ptr() as *const [G; OUT_428]) }; __ret } else { aiur_fn_428(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_13: G = G::from_u64(5); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(3); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_15, __v_8, __v_12, __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 __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_17, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(1); + let __ret: [G; OUT_427] = [__v_19, __v_18]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = { 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_427] = [__v_13, __v_17]; + record.function_queries[427].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_428: usize = 4; +const IN_428: usize = 4; +const OUT_428: usize = 2; +fn aiur_fn_428( + inp: [G; IN_428], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_428], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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 __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_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + match __v_7.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + 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]; + match __v_12.as_canonical_u64() { + 4u64 => { + match __v_15.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_23: G = __r_arr[0]; + let __v_24: G = G::from_u64(3); + let __v_25: G = (__v_23 - __v_24); + match __v_25.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(2); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_6, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = G::from_u64(1); + let __ret: [G; OUT_428] = [__v_28, __v_27]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = { 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_428] = [__v_26, __v_30]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __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_428] = [__v_23, __v_27]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_24, __v_25, __v_26, __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_428] = [__v_23, __v_27]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_428] = [__v_11, __v_15]; + record.function_queries[428].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_429: usize = 5; +const IN_429: usize = 5; +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_429], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = (__v_3 - __v_4); + match __v_5.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_429] = [__v_0]; + record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(8); + let __v_7: G = { let __values: [G; 4] = [__v_6, __v_1, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = G::from_u64(3); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_4 + __v_11); + let __r_arr: [G; OUT_429] = { let __args: [G; IN_429] = [__v_10, __v_1, __v_2, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[429].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_429] = unsafe { *(result.output.as_ptr() as *const [G; OUT_429]) }; __ret } else { aiur_fn_429(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_429] = [__v_13]; + record.function_queries[429].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_430: usize = 6; +const IN_430: usize = 6; +const OUT_430: usize = 2; +fn aiur_fn_430( + inp: [G; IN_430], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_430], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __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_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_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 __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 4] = [__v_12, __v_13, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_430] = [__v_11, __v_15]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_7.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + 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]; + match __v_12.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_24: G = __loaded[0]; + let __v_25: G = __loaded[1]; + let __v_26: G = __loaded[2]; + let __v_27: G = __loaded[3]; + let __v_28: G = __loaded[4]; + let __v_29: G = __loaded[5]; + let __v_30: G = __loaded[6]; + let __v_31: G = __loaded[7]; + let __v_32: G = __loaded[8]; + let __v_33: G = __loaded[9]; + let __v_34: G = __loaded[10]; + match __v_24.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_35: G = __r_arr[0]; + match __v_35.as_canonical_u64() { + 0u64 => { + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 4] = [__v_37, __v_38, __v_39, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_430] = [__v_36, __v_40]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_36: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_29, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_38, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_40: G = __r_arr[0]; + let __v_41: 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_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: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].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]; + match __v_42.as_canonical_u64() { + 2u64 => { + let __v_46: G = (__v_43 - __v_15); + match __v_46.as_canonical_u64() { + 0u64 => { + let __v_47: G = G::from_u64(2); + let __v_48: G = G::from_u64(0); + let __v_49: G = { let __values: [G; 4] = [__v_47, __v_37, __v_44, __v_48]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_41, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_51, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_52: G = __r_arr[0]; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_39, __v_52, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + match __v_53.as_canonical_u64() { + 1u64 => { + let __v_54: G = G::from_u64(1); + let __ret: [G; OUT_430] = [__v_54, __v_51]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(0); + let __v_57: G = G::from_u64(0); + let __v_58: G = { let __values: [G; 4] = [__v_55, __v_56, __v_57, __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 __ret: [G; OUT_430] = [__v_54, __v_58]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_53.as_canonical_u64())); + }, + } + }, + _ => { + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = { let __values: [G; 4] = [__v_48, __v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_47, __v_51]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = 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_430] = [__v_46, __v_50]; + record.function_queries[430].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +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_431], 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(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_431] = [__v_8]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_431] = [__v_3]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_1 - __v_5); + let __r_arr: [G; OUT_431] = { let __args: [G; IN_431] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[431].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_431] = unsafe { *(result.output.as_ptr() as *const [G; OUT_431]) }; __ret } else { aiur_fn_431(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_431] = [__v_7]; + record.function_queries[431].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_432: usize = 1; +const IN_432: usize = 1; +const OUT_432: usize = 2; +fn aiur_fn_432( + inp: [G; IN_432], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_432], 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_432] = [__v_5, __v_2]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 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_432] = [__v_5, __v_8]; + record.function_queries[432].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_433: usize = 1; +const IN_433: usize = 1; +const OUT_433: usize = 3; +fn aiur_fn_433( + inp: [G; IN_433], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_433], 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + match __v_1.as_canonical_u64() { + 5u64 => { + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_433] = [__v_5, __v_2, __v_3]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_6, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_10, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_433] = [__v_5, __v_9, __v_13]; + record.function_queries[433].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +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_434], 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(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_434] = [__v_8]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_3, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_434] = [__v_7]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_1 - __v_5); + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_434] = [__v_10]; + record.function_queries[434].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_435: usize = 4; +const IN_435: usize = 4; +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_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]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_436] = { let __args: [G; IN_436] = [__v_0, __v_5, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[436].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_436] = unsafe { *(result.output.as_ptr() as *const [G; OUT_436]) }; __ret } else { aiur_fn_436(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_435] = [__v_6]; + record.function_queries[435].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +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_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 __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]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_8]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_9, __v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { 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 = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_8, __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_436] = [__v_16]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__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[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_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() }); + } + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__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[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_23]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_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_437] = { let __args: [G; IN_437] = [__v_10, __v_9, __v_13, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_14]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_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_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_435] = { let __args: [G; IN_435] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(5); + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_5, __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 __ret: [G; OUT_436] = [__v_14]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_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_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_438] = { let __args: [G; IN_438] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(1); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + 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 __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_12, __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_436] = [__v_24]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_6, __v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_7, __v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_10, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_11]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_8]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_8]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + 8u64 => { + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_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 }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + match __v_12.as_canonical_u64() { + 2u64 => { + if (__v_13 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); + } + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + let __v_21: G = __loaded[4]; + let __v_22: G = __loaded[5]; + let __v_23: G = __loaded[6]; + let __v_24: G = __loaded[7]; + let __v_25: G = __loaded[8]; + let __v_26: G = __loaded[9]; + let __v_27: G = __loaded[10]; + match __v_17.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_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() }); + } + let __v_30: G = (__v_20 + __v_21); + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_19, __v_14, __v_30, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_22, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_35: G = __loaded[0]; + let __v_36: G = __loaded[1]; + let __v_37: G = __loaded[2]; + let __v_38: G = __loaded[3]; + let __v_39: G = __loaded[4]; + let __v_40: G = __loaded[5]; + let __v_41: G = __loaded[6]; + let __v_42: G = __loaded[7]; + let __v_43: G = __loaded[8]; + let __v_44: G = __loaded[9]; + let __v_45: G = __loaded[10]; + match __v_35.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_37, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_46, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_47, __v_6, __v_48, __v_5, __v_7, __v_31, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __ret: [G; OUT_436] = [__v_49]; + record.function_queries[436].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_35.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_437: usize = 6; +const IN_437: usize = 6; +const OUT_437: usize = 1; +fn aiur_fn_437( + inp: [G; IN_437], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_437], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __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_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() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_437] = [__v_10]; + record.function_queries[437].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_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_10, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_7, __v_14, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 3] = [__v_15, __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_437] = { let __args: [G; IN_437] = [__v_11, __v_8, __v_16, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_437] = [__v_17]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_398] = { let __args: [G; IN_398] = [__v_0, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[398].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_398] = unsafe { *(result.output.as_ptr() as *const [G; OUT_398]) }; __ret } else { aiur_fn_398(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_14, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __v_19: G = G::from_u64(1); + if (__v_16 != __v_19) { + return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_19.as_canonical_u64() }); + } + let __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_7, __v_17, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(1); + let __v_22: G = G::from_u64(1); + let __v_23: G = { let __values: [G; 3] = [__v_21, __v_22, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 3] = [__v_20, __v_7, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_437] = { let __args: [G; IN_437] = [__v_18, __v_8, __v_24, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[437].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_437] = unsafe { *(result.output.as_ptr() as *const [G; OUT_437]) }; __ret } else { aiur_fn_437(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_437] = [__v_25]; + record.function_queries[437].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_438: usize = 4; +const IN_438: usize = 4; +const OUT_438: usize = 1; +fn aiur_fn_438( + inp: [G; IN_438], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_438], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __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]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_438] = [__v_6]; + record.function_queries[438].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, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = G::from_u64(1); + if (__v_10 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + let __ret: [G; OUT_438] = [__v_11]; + record.function_queries[438].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_439: usize = 5; +const IN_439: usize = 5; +const OUT_439: usize = 0; +fn aiur_fn_439( + inp: [G; IN_439], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 = inp[4]; + let __r_arr: [G; OUT_435] = { let __args: [G; IN_435] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[435].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_435] = unsafe { *(result.output.as_ptr() as *const [G; OUT_435]) }; __ret } else { aiur_fn_435(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(1); + if (__v_6 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_7.as_canonical_u64() }); + } + let __ret: [G; OUT_439] = []; + record.function_queries[439].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_440: usize = 4; +const IN_440: usize = 4; +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_440], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __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_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_441] = { let __args: [G; IN_441] = [__v_0, __v_5, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[441].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_441] = unsafe { *(result.output.as_ptr() as *const [G; OUT_441]) }; __ret } else { aiur_fn_441(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_440] = [__v_6]; + record.function_queries[440].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_441: usize = 4; +const IN_441: usize = 4; +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_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 __v_3: G = inp[3]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_434] = { let __args: [G; IN_434] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[434].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_434] = unsafe { *(result.output.as_ptr() as *const [G; OUT_434]) }; __ret } else { aiur_fn_434(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_8]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_230] = { let __args: [G; IN_230] = [__v_9, __v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[230].get_mut(&__args[..]) { 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 = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = { let __values: [G; 3] = [__v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 4] = [__v_8, __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_441] = [__v_16]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__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[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_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() }); + } + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__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[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_22, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_23]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_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]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __v_13: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_11, __v_6, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_14]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_433] = { let __args: [G; IN_433] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[433].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_433] = unsafe { *(result.output.as_ptr() as *const [G; OUT_433]) }; __ret } else { aiur_fn_433(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = G::from_u64(1); + if (__v_14 != __v_17) { + return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_17.as_canonical_u64() }); + } + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_16, __v_6, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_19]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 3] = [__v_8, __v_5, __v_1]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_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_441] = [__v_13]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_442] = { let __args: [G; IN_442] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __v_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_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_442] = { let __args: [G; IN_442] = [__v_6, __v_10, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[442].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_442] = unsafe { *(result.output.as_ptr() as *const [G; OUT_442]) }; __ret } else { aiur_fn_442(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(1); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + 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 __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_12, __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_441] = [__v_24]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_7, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_9, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_10]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + match __v_5.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_451] = { let __args: [G; IN_451] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[451].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_451] = unsafe { *(result.output.as_ptr() as *const [G; OUT_451]) }; __ret } else { aiur_fn_451(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_8]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_452] = { let __args: [G; IN_452] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[452].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_452] = unsafe { *(result.output.as_ptr() as *const [G; OUT_452]) }; __ret } else { aiur_fn_452(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_8]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + 8u64 => { + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_8, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_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 }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + match __v_12.as_canonical_u64() { + 2u64 => { + if (__v_13 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); + } + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + let __v_21: G = __loaded[4]; + let __v_22: G = __loaded[5]; + let __v_23: G = __loaded[6]; + let __v_24: G = __loaded[7]; + let __v_25: G = __loaded[8]; + let __v_26: G = __loaded[9]; + let __v_27: G = __loaded[10]; + match __v_17.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_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() }); + } + let __v_30: G = (__v_20 + __v_21); + let __r_arr: [G; OUT_449] = { let __args: [G; IN_449] = [__v_19, __v_14, __v_30, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[449].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_449] = unsafe { *(result.output.as_ptr() as *const [G; OUT_449]) }; __ret } else { aiur_fn_449(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_22, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_34.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_35: G = __loaded[0]; + let __v_36: G = __loaded[1]; + let __v_37: G = __loaded[2]; + let __v_38: G = __loaded[3]; + let __v_39: G = __loaded[4]; + let __v_40: G = __loaded[5]; + let __v_41: G = __loaded[6]; + let __v_42: G = __loaded[7]; + let __v_43: G = __loaded[8]; + let __v_44: G = __loaded[9]; + let __v_45: G = __loaded[10]; + match __v_35.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_37, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __r_arr: [G; OUT_445] = { let __args: [G; IN_445] = [__v_46, __v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_47, __v_6, __v_48, __v_5, __v_7, __v_31, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __ret: [G; OUT_441] = [__v_49]; + record.function_queries[441].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_35.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_442: usize = 4; +const IN_442: usize = 4; +const OUT_442: usize = 1; +fn aiur_fn_442( + inp: [G; IN_442], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_442], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __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]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_442] = [__v_6]; + record.function_queries[442].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, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_432] = { let __args: [G; IN_432] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[432].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_432] = unsafe { *(result.output.as_ptr() as *const [G; OUT_432]) }; __ret } else { aiur_fn_432(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __v_12: G = G::from_u64(1); + if (__v_10 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + let __ret: [G; OUT_442] = [__v_11]; + record.function_queries[442].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_443: usize = 11; +const IN_443: usize = 11; +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_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 __v_3: G = inp[3]; + 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]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_443] = [__v_2]; + record.function_queries[443].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_444: usize = 11; +const IN_444: usize = 11; +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_444], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __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]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_444] = [__v_1]; + record.function_queries[444].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +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_445], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_445] = [__v_0]; + record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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() { + 5u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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 __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_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_445] = { let __args: [G; IN_445] = [__v_11, __v_9, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[445].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_445] = unsafe { *(result.output.as_ptr() as *const [G; OUT_445]) }; __ret } else { aiur_fn_445(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_445] = [__v_14]; + record.function_queries[445].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_446: usize = 9; +const IN_446: usize = 9; +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_446], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __v_13: G = (__v_1 - __v_2); + match __v_13.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_450] = { let __args: [G; IN_450] = [__v_5, __v_10, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[450].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_450] = unsafe { *(result.output.as_ptr() as *const [G; OUT_450]) }; __ret } else { aiur_fn_450(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_446] = [__v_10]; + record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_447] = { let __args: [G; IN_447] = [__v_5, __v_10, __v_11, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[447].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_447] = unsafe { *(result.output.as_ptr() as *const [G; OUT_447]) }; __ret } else { aiur_fn_447(__args, record, io_buffer, __cu)? } }; + let __v_14: G = G::from_u64(8); + let __v_15: G = { let __values: [G; 4] = [__v_14, __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_16: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_11, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_2 + __v_18); + let __r_arr: [G; OUT_446] = { let __args: [G; IN_446] = [__v_17, __v_1, __v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[446].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_446] = unsafe { *(result.output.as_ptr() as *const [G; OUT_446]) }; __ret } else { aiur_fn_446(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_446] = [__v_20]; + record.function_queries[446].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_447: usize = 6; +const IN_447: usize = 6; +const OUT_447: usize = 0; +fn aiur_fn_447( + inp: [G; IN_447], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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 __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_447] = []; + record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_6: 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_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { 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_12: G = __r_arr[0]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_447] = []; + record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_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() }); + } + let __ret: [G; OUT_447] = []; + record.function_queries[447].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +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_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]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_448] = [__v_5]; + record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_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]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __v_10: G = G::from_u64(1); + let __v_11: G = (__v_1 - __v_10); + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_8, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_448] = [__v_12]; + record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_448] = [__v_5]; + record.function_queries[448].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_449: usize = 6; +const IN_449: usize = 6; +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_449], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_448] = { let __args: [G; IN_448] = [__v_6, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[448].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_448] = unsafe { *(result.output.as_ptr() as *const [G; OUT_448]) }; __ret } else { aiur_fn_448(__args, record, io_buffer, __cu)? } }; + let __v_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]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { 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_17: G = __r_arr[0]; + let __ret: [G; OUT_449] = [__v_17]; + 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_449] = [__v_12]; + record.function_queries[449].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 = 0; +fn aiur_fn_450( + inp: [G; IN_450], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_450], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_450] = []; + record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __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_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { 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_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(1); + if (__v_11 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + let __ret: [G; OUT_450] = []; + record.function_queries[450].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_451: usize = 1; +const IN_451: usize = 1; +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_451], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_276] = { let __args: [G; IN_276] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[276].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_276] = unsafe { *(result.output.as_ptr() as *const [G; OUT_276]) }; __ret } else { aiur_fn_276(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = G::from_u64(0); + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(2); + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_4, __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_451] = [__v_9]; + record.function_queries[451].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_452: usize = 1; +const IN_452: usize = 1; +const OUT_452: usize = 1; +fn aiur_fn_452( + inp: [G; IN_452], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_452], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_294] = { let __args: [G; IN_294] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[294].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_294] = unsafe { *(result.output.as_ptr() as *const [G; OUT_294]) }; __ret } else { aiur_fn_294(__args, record, io_buffer, __cu)? } }; + let __v_1: G = __r_arr[0]; + let __v_2: G = G::from_u64(0); + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_1, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(2); + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(1); + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_4, __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_452] = [__v_9]; + record.function_queries[452].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +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_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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_453] = [__v_2]; + record.function_queries[453].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_2 + __v_7); + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_453] = [__v_9]; + record.function_queries[453].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_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_454], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = (__v_0 - __v_1); + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_454] = [__v_6]; + record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_385] = { let __args: [G; IN_385] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[385].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_385] = unsafe { *(result.output.as_ptr() as *const [G; OUT_385]) }; __ret } else { aiur_fn_385(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_387] = { let __args: [G; IN_387] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[387].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_387] = unsafe { *(result.output.as_ptr() as *const [G; OUT_387]) }; __ret } else { aiur_fn_387(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_393] = { let __args: [G; IN_393] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[393].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_393] = unsafe { *(result.output.as_ptr() as *const [G; OUT_393]) }; __ret } else { aiur_fn_393(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_455] = { let __args: [G; IN_455] = [__v_0, __v_1, __v_9, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[455].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_455] = unsafe { *(result.output.as_ptr() as *const [G; OUT_455]) }; __ret } else { aiur_fn_455(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_454] = [__v_10]; + record.function_queries[454].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_455: usize = 5; +const IN_455: usize = 5; +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_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 __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_6]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_461] = { let __args: [G; IN_461] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[461].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_461] = unsafe { *(result.output.as_ptr() as *const [G; OUT_461]) }; __ret } else { aiur_fn_461(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_7]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_409] = { let __args: [G; IN_409] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[409].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_409] = unsafe { *(result.output.as_ptr() as *const [G; OUT_409]) }; __ret } else { aiur_fn_409(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = (__v_7 - __v_8); + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_10]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_456] = { let __args: [G; IN_456] = [__v_7, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[456].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_456] = unsafe { *(result.output.as_ptr() as *const [G; OUT_456]) }; __ret } else { aiur_fn_456(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_11]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_471] = { let __args: [G; IN_471] = [__v_7, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[471].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_471] = unsafe { *(result.output.as_ptr() as *const [G; OUT_471]) }; __ret } else { aiur_fn_471(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_12]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = (__v_12 - __v_13); + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_15: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_15]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_457] = { let __args: [G; IN_457] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[457].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_457] = unsafe { *(result.output.as_ptr() as *const [G; OUT_457]) }; __ret } else { aiur_fn_457(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + match __v_15.as_canonical_u64() { + 1u64 => { + let __v_16: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_16]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_459] = { let __args: [G; IN_459] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[459].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_459] = unsafe { *(result.output.as_ptr() as *const [G; OUT_459]) }; __ret } else { aiur_fn_459(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { + 1u64 => { + let __v_17: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_17]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + match __v_17.as_canonical_u64() { + 1u64 => { + let __v_18: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_18]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_466] = { let __args: [G; IN_466] = [__v_13, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[466].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_466] = unsafe { *(result.output.as_ptr() as *const [G; OUT_466]) }; __ret } else { aiur_fn_466(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + match __v_18.as_canonical_u64() { + 1u64 => { + let __v_19: G = G::from_u64(1); + let __ret: [G; OUT_455] = [__v_19]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_465] = { let __args: [G; IN_465] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[465].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_465] = unsafe { *(result.output.as_ptr() as *const [G; OUT_465]) }; __ret } else { aiur_fn_465(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + match __v_19.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_455] = [__v_20]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_21: G = G::from_u64(16); + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_12, __v_13, __v_21, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = __r_arr[1]; + match __v_22.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_455] = [__v_23]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_468] = { let __args: [G; IN_468] = [__v_12, __v_13, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[468].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_468] = unsafe { *(result.output.as_ptr() as *const [G; OUT_468]) }; __ret } else { aiur_fn_468(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __ret: [G; OUT_455] = [__v_24]; + record.function_queries[455].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_19.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_16.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_456: usize = 5; +const IN_456: usize = 5; +const OUT_456: usize = 1; +fn aiur_fn_456( + inp: [G; IN_456], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_456], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; + let __ret: [G; OUT_456] = [__v_19]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_13]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 4u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __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_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_456] = [__v_16]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_14]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_13]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 5u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __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_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_456] = [__v_16]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_14]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_13]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_456] = [__v_9]; + record.function_queries[456].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_457: usize = 5; +const IN_457: usize = 5; +const OUT_457: usize = 1; +fn aiur_fn_457( + inp: [G; IN_457], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_457], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_458] = { let __args: [G; IN_458] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[458].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_458] = unsafe { *(result.output.as_ptr() as *const [G; OUT_458]) }; __ret } else { aiur_fn_458(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_457] = [__v_7]; + record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_7, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_457] = [__v_8]; + record.function_queries[457].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_458: usize = 4; +const IN_458: usize = 4; +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_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 __v_3: G = inp[3]; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_4, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_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]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_13: G = G::from_u64(1); + let __ret: [G; OUT_458] = [__v_13]; + record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_458] = [__v_13]; + record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_458] = [__v_10]; + record.function_queries[458].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_459: usize = 5; +const IN_459: usize = 5; +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_459], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_460] = { let __args: [G; IN_460] = [__v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[460].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_460] = unsafe { *(result.output.as_ptr() as *const [G; OUT_460]) }; __ret } else { aiur_fn_460(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_459] = [__v_8]; + record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_440] = { let __args: [G; IN_440] = [__v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[440].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_440] = unsafe { *(result.output.as_ptr() as *const [G; OUT_440]) }; __ret } else { aiur_fn_440(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_5, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_459] = [__v_9]; + record.function_queries[459].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +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_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_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_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 }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 5u64 => { + match __v_15.as_canonical_u64() { + 1u64 => { + let __v_20: G = G::from_u64(0); + let __ret: [G; OUT_460] = [__v_20]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_20: G = __r_arr[0]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_14, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_24: G = __loaded[0]; + let __v_25: G = __loaded[1]; + let __v_26: G = __loaded[2]; + let __v_27: G = __loaded[3]; + let __v_28: G = __loaded[4]; + let __v_29: G = __loaded[5]; + let __v_30: G = __loaded[6]; + let __v_31: G = __loaded[7]; + let __v_32: G = __loaded[8]; + let __v_33: G = __loaded[9]; + let __v_34: G = __loaded[10]; + match __v_24.as_canonical_u64() { + 6u64 => { + match __v_30.as_canonical_u64() { + 0u64 => { + let __v_35: G = G::from_u64(1); + let __ret: [G; OUT_460] = [__v_35]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_35: G = G::from_u64(0); + let __ret: [G; OUT_460] = [__v_35]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_35: G = G::from_u64(0); + let __ret: [G; OUT_460] = [__v_35]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_21: G = G::from_u64(0); + let __ret: [G; OUT_460] = [__v_21]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + _ => { + let __v_20: G = G::from_u64(0); + let __ret: [G; OUT_460] = [__v_20]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_460] = [__v_8]; + record.function_queries[460].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_461: usize = 5; +const IN_461: usize = 5; +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_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 __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_0, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_461] = [__v_6]; + record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_462] = { let __args: [G; IN_462] = [__v_1, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[462].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_462] = unsafe { *(result.output.as_ptr() as *const [G; OUT_462]) }; __ret } else { aiur_fn_462(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_461] = [__v_6]; + record.function_queries[461].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_462: usize = 5; +const IN_462: usize = 5; +const OUT_462: usize = 1; +fn aiur_fn_462( + inp: [G; IN_462], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_462], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 7u64 => { + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_379] = { let __args: [G; IN_379] = [__v_7, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[379].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_379] = unsafe { *(result.output.as_ptr() as *const [G; OUT_379]) }; __ret } else { aiur_fn_379(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_10, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_462] = [__v_11]; + record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_462] = [__v_11]; + record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_462] = [__v_9]; + record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_462] = [__v_9]; + record.function_queries[462].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +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_463], 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() { + 7u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_323] = { let __args: [G; IN_323] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[323].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_323] = unsafe { *(result.output.as_ptr() as *const [G; OUT_323]) }; __ret } else { aiur_fn_323(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_463] = [__v_6]; + record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_463] = [__v_6]; + record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_277] = { let __args: [G; IN_277] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[277].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_277] = unsafe { *(result.output.as_ptr() as *const [G; OUT_277]) }; __ret } else { aiur_fn_277(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_463] = [__v_8]; + record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_463] = [__v_6]; + record.function_queries[463].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_464: usize = 2; +const IN_464: usize = 2; +const OUT_464: usize = 3; +fn aiur_fn_464( + inp: [G; IN_464], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __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() { + 7u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + 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 __r_arr: [G; OUT_342] = { let __args: [G; IN_342] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[342].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_342] = unsafe { *(result.output.as_ptr() as *const [G; OUT_342]) }; __ret } else { aiur_fn_342(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_464] = [__v_6, __v_10, __v_4]; + record.function_queries[464].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(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_464] = [__v_6, __v_0, __v_9]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_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_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_278] = { let __args: [G; IN_278] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[278].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_278] = unsafe { *(result.output.as_ptr() as *const [G; OUT_278]) }; __ret } else { aiur_fn_278(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + match __v_12.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = __r_arr[2]; + let __v_16: G = G::from_u64(1); + let __r_arr: [G; OUT_307] = { let __args: [G; IN_307] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[307].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_307] = unsafe { *(result.output.as_ptr() as *const [G; OUT_307]) }; __ret } else { aiur_fn_307(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_464] = [__v_16, __v_14, __v_17]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 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_464] = [__v_13, __v_0, __v_16]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + 3u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_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]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + match __v_10.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_280] = { let __args: [G; IN_280] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[280].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_280] = unsafe { *(result.output.as_ptr() as *const [G; OUT_280]) }; __ret } else { aiur_fn_280(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + match __v_16.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_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_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + match __v_17.as_canonical_u64() { + 7u64 => { + match __v_18.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __v_23: G = __r_arr[2]; + match __v_21.as_canonical_u64() { + 1u64 => { + let __v_24: G = G::from_u64(1); + let __r_arr: [G; OUT_309] = { let __args: [G; IN_309] = [__v_23, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[309].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_309] = unsafe { *(result.output.as_ptr() as *const [G; OUT_309]) }; __ret } else { aiur_fn_309(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_464] = [__v_24, __v_22, __v_25]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_24: G = G::from_u64(1); + let __ret: [G; OUT_464] = [__v_24, __v_8, __v_19]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + _ => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_464] = [__v_21, __v_0, __v_24]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 10] = [__v_22, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_464] = [__v_21, __v_0, __v_24]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(1); + let __v_19: G = G::from_u64(1); + let __v_20: G = { let __values: [G; 10] = [__v_18, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19, __v_19]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_464] = [__v_17, __v_0, __v_20]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_16.as_canonical_u64())); + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 10] = [__v_15, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_464] = [__v_14, __v_0, __v_17]; + record.function_queries[464].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(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_464] = [__v_10, __v_0, __v_13]; + record.function_queries[464].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(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_464] = [__v_6, __v_0, __v_9]; + record.function_queries[464].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_465: usize = 5; +const IN_465: usize = 5; +const OUT_465: usize = 2; +fn aiur_fn_465( + inp: [G; IN_465], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __v_4: G = inp[4]; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_463] = { let __args: [G; IN_463] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[463].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_463] = unsafe { *(result.output.as_ptr() as *const [G; OUT_463]) }; __ret } else { aiur_fn_463(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = (__v_5 * __v_6); + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __ret: [G; OUT_465] = [__v_8, __v_9]; + record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __r_arr: [G; OUT_464] = { let __args: [G; IN_464] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[464].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_464] = unsafe { *(result.output.as_ptr() as *const [G; OUT_464]) }; __ret } else { aiur_fn_464(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __v_14: G = (__v_8 * __v_11); + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __ret: [G; OUT_465] = [__v_15, __v_16]; + record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_235] = { let __args: [G; IN_235] = [__v_10, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[235].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_235] = unsafe { *(result.output.as_ptr() as *const [G; OUT_235]) }; __ret } else { aiur_fn_235(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + match __v_15.as_canonical_u64() { + 0u64 => { + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __ret: [G; OUT_465] = [__v_16, __v_17]; + record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_16: G = G::from_u64(1); + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_9, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_465] = [__v_16, __v_17]; + record.function_queries[465].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_466: usize = 5; +const IN_466: usize = 5; +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_466], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + 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 !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 __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_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + match __v_7.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + 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]; + match __v_12.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_23: G = __r_arr[0]; + let __v_24: G = (__v_17 + __v_18); + let __v_25: G = (__v_23 - __v_24); + match __v_25.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_26.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_27: G = __loaded[0]; + let __v_28: G = __loaded[1]; + let __v_29: G = __loaded[2]; + let __v_30: G = __loaded[3]; + let __v_31: G = __loaded[4]; + let __v_32: G = __loaded[5]; + let __v_33: G = __loaded[6]; + let __v_34: G = __loaded[7]; + let __v_35: G = __loaded[8]; + let __v_36: G = __loaded[9]; + let __v_37: G = __loaded[10]; + match __v_27.as_canonical_u64() { + 5u64 => { + let __v_38: G = G::from_bool((__v_33 == G::ZERO)); + let __v_39: G = G::from_bool((__v_31 == G::ZERO)); + let __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 !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_40: G = __r_arr[0]; + let __v_41: G = G::from_u64(1); + let __v_42: G = (__v_40 - __v_41); + let __v_43: G = G::from_bool((__v_42 == G::ZERO)); + let __v_44: G = (__v_39 * __v_43); + let __v_45: G = (__v_38 * __v_44); + match __v_45.as_canonical_u64() { + 0u64 => { + let __v_46: G = G::from_u64(0); + let __ret: [G; OUT_466] = [__v_46]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_46: G = G::from_u64(0); + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_15, __v_17, __v_18, __v_0, __v_6, __v_46, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __ret: [G; OUT_466] = [__v_47]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); + }, + } + }, + _ => { + let __v_38: G = G::from_u64(0); + let __ret: [G; OUT_466] = [__v_38]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __ret: [G; OUT_466] = [__v_26]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_23: G = G::from_u64(0); + let __ret: [G; OUT_466] = [__v_23]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_466] = [__v_11]; + record.function_queries[466].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_467: usize = 9; +const IN_467: usize = 9; +const OUT_467: usize = 1; +fn aiur_fn_467( + inp: [G; IN_467], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_467], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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 = (__v_2 - __v_5); + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(1); + let __ret: [G; OUT_467] = [__v_10]; + record.function_queries[467].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_0, __v_5, __v_3]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = (__v_1 + __v_5); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_11, __v_13, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 0u64 => { + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_467] = [__v_15]; + record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_15: G = G::from_u64(1); + let __v_16: G = (__v_5 + __v_15); + let __r_arr: [G; OUT_467] = { let __args: [G; IN_467] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_16, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[467].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_467] = unsafe { *(result.output.as_ptr() as *const [G; OUT_467]) }; __ret } else { aiur_fn_467(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_467] = [__v_17]; + record.function_queries[467].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_468: usize = 5; +const IN_468: usize = 5; +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_468], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __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_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __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_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_16: G = __loaded[0]; + let __v_17: G = __loaded[1]; + let __v_18: G = __loaded[2]; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_19]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + 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_468] = [__v_13]; + record.function_queries[468].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_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_13: G = (__v_6 - __v_10); + match __v_13.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(1); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + 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_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 2u64 => { + let __v_13: G = (__v_6 - __v_10); + match __v_13.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_7, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + 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_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + 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_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 4u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __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_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_16]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_6, __v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 5u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = { let __values: [G; 3] = [__v_14, __v_6, __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_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_15, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_16]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + 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_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 6u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + match __v_9.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + match __v_14.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_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_454] = { let __args: [G; IN_454] = [__v_8, __v_12, __v_16, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_17]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_15]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_14]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + 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_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 7u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + match __v_9.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_237] = { let __args: [G; IN_237] = [__v_6, __v_7, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[237].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_237] = unsafe { *(result.output.as_ptr() as *const [G; OUT_237]) }; __ret } else { aiur_fn_237(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + 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_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 8u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + match __v_9.as_canonical_u64() { + 8u64 => { + let __v_13: G = (__v_6 - __v_10); + let __v_14: G = G::from_bool((__v_13 == G::ZERO)); + let __v_15: G = (__v_7 - __v_11); + let __v_16: G = G::from_bool((__v_15 == G::ZERO)); + let __v_17: G = (__v_14 * __v_16); + match __v_17.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_8, __v_12, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_18]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_468] = [__v_18]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_469] = { let __args: [G; IN_469] = [__v_10, __v_11, __v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[469].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_469] = unsafe { *(result.output.as_ptr() as *const [G; OUT_469]) }; __ret } else { aiur_fn_469(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_468] = [__v_13]; + 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_468] = [__v_13]; + record.function_queries[468].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_469: usize = 6; +const IN_469: usize = 6; +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_469], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_9, __v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 3] = [__v_16, __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_454] = { let __args: [G; IN_454] = [__v_1, __v_15, __v_17, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __ret: [G; OUT_469] = [__v_18]; + record.function_queries[469].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_470: usize = 2; +const IN_470: usize = 2; +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_470], 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_470] = [__v_8]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_470] = [__v_8]; + record.function_queries[470].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 __v_8: G = G::from_u64(0); + let __ret: [G; OUT_470] = [__v_8]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { 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_14: G = __r_arr[0]; + match __v_14.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_470] = [__v_15]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_470] = [__v_15]; + record.function_queries[470].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_471: usize = 5; +const IN_471: usize = 5; +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_471], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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 __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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __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 }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 2u64 => { + let __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_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() { + 2u64 => { + let __v_17: G = (__v_10 - __v_14); + match __v_17.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_11, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + match __v_18.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(0); + let __ret: [G; OUT_471] = [__v_19]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_20: G = __r_arr[0]; + let __v_21: G = (__v_19 - __v_20); + match __v_21.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_6, __v_8, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_471] = [__v_22]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_22: G = G::from_u64(0); + let __ret: [G; OUT_471] = [__v_22]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_471] = [__v_18]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_17: G = G::from_u64(0); + let __ret: [G; OUT_471] = [__v_17]; + 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_471] = [__v_13]; + record.function_queries[471].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_472: usize = 5; +const IN_472: usize = 5; +const OUT_472: usize = 1; +fn aiur_fn_472( + inp: [G; IN_472], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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 __v_4: G = inp[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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 __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_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_472] = [__v_11]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_472] = [__v_11]; + record.function_queries[472].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_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_472] = [__v_11]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_6, __v_9, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 0u64 => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_472] = [__v_12]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_7, __v_10, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_472] = [__v_12]; + record.function_queries[472].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_473: usize = 2; +const IN_473: usize = 2; +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_473], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(1); + let __ret: [G; OUT_473] = [__v_14]; + record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_14: G = G::from_u64(1); + let __ret: [G; OUT_473] = [__v_14]; + record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_473] = [__v_14]; + record.function_queries[473].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_474: usize = 2; +const IN_474: usize = 2; +const OUT_474: usize = 1; +fn aiur_fn_474( + inp: [G; IN_474], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_474] = [__v_8]; + record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_474] = [__v_14]; + record.function_queries[474].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_475: usize = 2; +const IN_475: usize = 2; +const OUT_475: usize = 2; +fn aiur_fn_475( + inp: [G; IN_475], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_475], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_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 }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_20, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_475] = [__v_21, __v_22]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_12, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_20, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_475] = [__v_21, __v_22]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_20: G = G::from_u64(0); + let __ret: [G; OUT_475] = [__v_20, __v_0]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_475] = [__v_8, __v_0]; + record.function_queries[475].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_476: usize = 2; +const IN_476: usize = 2; +const OUT_476: usize = 2; +fn aiur_fn_476( + inp: [G; IN_476], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_476], 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_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_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 }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __v_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(8); + let __v_11: G = { let __values: [G; 4] = [__v_10, __v_5, __v_6, __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_12: G = G::from_u64(1); + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_476] = [__v_12, __v_13]; + record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_476] = [__v_10, __v_0]; + record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_476] = [__v_8, __v_0]; + record.function_queries[476].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_477: usize = 6; +const IN_477: usize = 6; +const OUT_477: usize = 2; +fn aiur_fn_477( + inp: [G; IN_477], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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 __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_477] = [__v_6, __v_7]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = (__v_0 - __v_1); + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_477] = [__v_7, __v_8]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_200] = unsafe { *(result.output.as_ptr() as *const [G; OUT_200]) }; __ret } else { aiur_fn_200(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + 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 !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_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_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_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + match __v_11.as_canonical_u64() { + 2u64 => { + let __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_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + let __v_18: G = __loaded[3]; + match __v_15.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_478] = { let __args: [G; IN_478] = [__v_12, __v_13, __v_8, __v_16, __v_17, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[478].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_478] = unsafe { *(result.output.as_ptr() as *const [G; OUT_478]) }; __ret } else { aiur_fn_478(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + match __v_19.as_canonical_u64() { + 1u64 => { + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(1); + let __ret: [G; OUT_477] = [__v_20, __v_21]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_479] = { let __args: [G; IN_479] = [__v_12, __v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[479].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_479] = unsafe { *(result.output.as_ptr() as *const [G; OUT_479]) }; __ret } else { aiur_fn_479(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __ret: [G; OUT_477] = [__v_20, __v_21]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_480] = { let __args: [G; IN_480] = [__v_12, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[480].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_480] = unsafe { *(result.output.as_ptr() as *const [G; OUT_480]) }; __ret } else { aiur_fn_480(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __ret: [G; OUT_477] = [__v_19, __v_20]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_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_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + let __v_18: G = __loaded[3]; + match __v_15.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_481] = { let __args: [G; IN_481] = [__v_16, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[481].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_481] = unsafe { *(result.output.as_ptr() as *const [G; OUT_481]) }; __ret } else { aiur_fn_481(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __ret: [G; OUT_477] = [__v_19, __v_20]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __ret: [G; OUT_477] = [__v_19, __v_20]; + record.function_queries[477].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_478: usize = 9; +const IN_478: usize = 9; +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_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 __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 = (__v_0 - __v_3); + match __v_9.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_470] = { let __args: [G; IN_470] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[470].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_470] = unsafe { *(result.output.as_ptr() as *const [G; OUT_470]) }; __ret } else { aiur_fn_470(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + match __v_10.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_478] = [__v_11]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !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_11: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_12: G = __r_arr[0]; + let __v_13: G = (__v_11 - __v_12); + match __v_13.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_472] = { let __args: [G; IN_472] = [__v_2, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[472].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_472] = unsafe { *(result.output.as_ptr() as *const [G; OUT_472]) }; __ret } else { aiur_fn_472(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_478] = [__v_14]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_478] = [__v_14]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_478] = [__v_10]; + record.function_queries[478].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_479: usize = 8; +const IN_479: usize = 8; +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_479], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_479] = [__v_10, __v_11]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_479] = [__v_10, __v_11]; + record.function_queries[479].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 __ret: [G; OUT_479] = [__v_10, __v_11]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 1u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_479] = [__v_10, __v_11]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_474] = { let __args: [G; IN_474] = [__v_1, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[474].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_474] = unsafe { *(result.output.as_ptr() as *const [G; OUT_474]) }; __ret } else { aiur_fn_474(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = { let __a_val = __v_11.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 __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_479] = [__v_13, __v_14]; + record.function_queries[479].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_11.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_483] = { let __args: [G; IN_483] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __ret: [G; OUT_479] = [__v_14, __v_15]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_484] = { let __args: [G; IN_484] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[484].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_484] = unsafe { *(result.output.as_ptr() as *const [G; OUT_484]) }; __ret } else { aiur_fn_484(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __ret: [G; OUT_479] = [__v_14, __v_15]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_479] = [__v_10, __v_11]; + record.function_queries[479].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 __ret: [G; OUT_479] = [__v_10, __v_11]; + record.function_queries[479].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_480: usize = 7; +const IN_480: usize = 7; +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_480], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_480] = [__v_8, __v_9]; + record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_3 - __v_11); + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_1, __v_10, __v_12, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_480] = [__v_13, __v_14]; + record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_482] = { let __args: [G; IN_482] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[482].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_482] = unsafe { *(result.output.as_ptr() as *const [G; OUT_482]) }; __ret } else { aiur_fn_482(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_480] = [__v_10, __v_11]; + record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_480] = [__v_8, __v_9]; + record.function_queries[480].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_481: usize = 7; +const IN_481: usize = 7; +const OUT_481: usize = 2; +fn aiur_fn_481( + inp: [G; IN_481], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_481], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_473] = { let __args: [G; IN_473] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[473].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_473] = unsafe { *(result.output.as_ptr() as *const [G; OUT_473]) }; __ret } else { aiur_fn_473(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_481] = [__v_8, __v_9]; + record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_476] = { let __args: [G; IN_476] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[476].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_476] = unsafe { *(result.output.as_ptr() as *const [G; OUT_476]) }; __ret } else { aiur_fn_476(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_3 - __v_11); + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_10, __v_2, __v_12, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_481] = [__v_13, __v_14]; + record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_483] = { let __args: [G; IN_483] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[483].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_483] = unsafe { *(result.output.as_ptr() as *const [G; OUT_483]) }; __ret } else { aiur_fn_483(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_481] = [__v_10, __v_11]; + record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_481] = [__v_8, __v_9]; + record.function_queries[481].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_482: usize = 6; +const IN_482: usize = 6; +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_482], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 - __v_9); + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_8, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_482] = [__v_11, __v_12]; + record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_482] = [__v_8, __v_9]; + record.function_queries[482].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_483: usize = 6; +const IN_483: usize = 6; +const OUT_483: usize = 2; +fn aiur_fn_483( + inp: [G; IN_483], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_483], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __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_475] = { let __args: [G; IN_475] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 - __v_9); + let __r_arr: [G; OUT_477] = { let __args: [G; IN_477] = [__v_0, __v_8, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_483] = [__v_11, __v_12]; + record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_483] = [__v_8, __v_9]; + record.function_queries[483].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_484: usize = 6; +const IN_484: usize = 6; +const OUT_484: usize = 2; +fn aiur_fn_484( + inp: [G; IN_484], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_484], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_475] = { let __args: [G; IN_475] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[475].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_475] = unsafe { *(result.output.as_ptr() as *const [G; OUT_475]) }; __ret } else { aiur_fn_475(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_7, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_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_477] = { let __args: [G; IN_477] = [__v_10, __v_11, __v_13, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[477].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_477] = unsafe { *(result.output.as_ptr() as *const [G; OUT_477]) }; __ret } else { aiur_fn_477(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __ret: [G; OUT_484] = [__v_14, __v_15]; + record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_484] = [__v_10, __v_11]; + record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_484] = [__v_8, __v_9]; + record.function_queries[484].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_485: usize = 6; +const IN_485: usize = 6; +const OUT_485: usize = 0; +fn aiur_fn_485( + inp: [G; IN_485], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_485], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = (__v_1 + __v_3); + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + 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 !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 __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_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + match __v_10.as_canonical_u64() { + 2u64 => { + if (__v_11 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_487] = { let __args: [G; IN_487] = [__v_12, __v_5, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_15: G = __r_arr[0]; + let __v_16: G = (__v_1 + __v_2); + if (__v_15 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); + } + let __v_17: G = G::from_u64(0); + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_9, __v_1, __v_3, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_485] = []; + record.function_queries[485].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +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_486], 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_486] = [__v_0]; + record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 5u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 - __v_6); + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_486] = [__v_8]; + record.function_queries[486].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_487: usize = 3; +const IN_487: usize = 3; +const OUT_487: usize = 0; +fn aiur_fn_487( + inp: [G; IN_487], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_487], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !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_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() }); + } + let __ret: [G; OUT_487] = []; + record.function_queries[487].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __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_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_6.as_canonical_u64() { + 4u64 => { + if (__v_7 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_2.as_canonical_u64() }); + } + let __v_9: G = G::from_u64(1); + 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_487] = { let __args: [G; IN_487] = [__v_5, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[487].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_487] = unsafe { *(result.output.as_ptr() as *const [G; OUT_487]) }; __ret } else { aiur_fn_487(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_487] = []; + record.function_queries[487].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_488: usize = 4; +const IN_488: usize = 4; +const OUT_488: usize = 0; +fn aiur_fn_488( + inp: [G; IN_488], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 = inp[3]; + let __v_4: G = (__v_1 - __v_3); + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_488] = []; + record.function_queries[488].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_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_12: G = (__v_2 + __v_1); + let __v_13: G = G::from_u64(1); + let __v_14: G = (__v_12 - __v_13); + let __v_15: G = (__v_14 - __v_3); + if (__v_9 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_15.as_canonical_u64() }); + } + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_3 + __v_16); + let __r_arr: [G; OUT_488] = { let __args: [G; IN_488] = [__v_7, __v_1, __v_2, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[488].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_488] = unsafe { *(result.output.as_ptr() as *const [G; OUT_488]) }; __ret } else { aiur_fn_488(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_488] = []; + record.function_queries[488].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_489: usize = 2; +const IN_489: usize = 2; +const OUT_489: usize = 3; +fn aiur_fn_489( + inp: [G; IN_489], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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 __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]; + let __ret: [G; OUT_489] = [__v_6, __v_7, __v_8]; + record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 5u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 - __v_6); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __v_10: G = __r_arr[2]; + let __ret: [G; OUT_489] = [__v_8, __v_9, __v_10]; + record.function_queries[489].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_490: usize = 8; +const IN_490: usize = 8; +const OUT_490: usize = 0; +fn aiur_fn_490( + inp: [G; IN_490], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_490], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_490] = []; + record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__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[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_490] = []; + record.function_queries[490].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_491: usize = 8; +const IN_491: usize = 8; +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_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]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_492] = { let __args: [G; IN_492] = [__v_0, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_491] = []; + record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 5u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 3] = [__v_12, __v_9, __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_14: G = G::from_u64(1); + let __v_15: G = (__v_1 - __v_14); + let __r_arr: [G; OUT_491] = { let __args: [G; IN_491] = [__v_10, __v_15, __v_2, __v_3, __v_4, __v_13, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[491].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_491] = unsafe { *(result.output.as_ptr() as *const [G; OUT_491]) }; __ret } else { aiur_fn_491(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_491] = []; + record.function_queries[491].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_492: usize = 7; +const IN_492: usize = 7; +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_492], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __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_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + match __v_7.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_8, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; 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: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_12, __v_13, __v_14, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + 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() }); + } + let __v_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 3] = [__v_17, __v_8, __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_492] = { let __args: [G; IN_492] = [__v_9, __v_1, __v_2, __v_3, __v_18, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[492].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_492] = unsafe { *(result.output.as_ptr() as *const [G; OUT_492]) }; __ret } else { aiur_fn_492(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_492] = []; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_492] = []; + record.function_queries[492].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_493: usize = 6; +const IN_493: usize = 6; +const OUT_493: usize = 0; +fn aiur_fn_493( + inp: [G; IN_493], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_0, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_6, __v_8, __v_7, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_493] = []; + record.function_queries[493].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_494: usize = 2; +const IN_494: usize = 2; +const OUT_494: usize = 1; +fn aiur_fn_494( + inp: [G; IN_494], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_494], 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_494] = [__v_0]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 5u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 - __v_6); + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_494] = [__v_8]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_494] = [__v_0]; + record.function_queries[494].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_495: usize = 3; +const IN_495: usize = 3; +const OUT_495: usize = 2; +fn aiur_fn_495( + inp: [G; IN_495], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_495] = [__v_0, __v_2]; + record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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() { + 5u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 3] = [__v_7, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_1 - __v_9); + let __r_arr: [G; OUT_495] = { let __args: [G; IN_495] = [__v_5, __v_10, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_495] = [__v_11, __v_12]; + record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_495] = [__v_0, __v_2]; + record.function_queries[495].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_496: usize = 5; +const IN_496: usize = 5; +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_496], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_497] = { let __args: [G; IN_497] = [__v_6, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_6, __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_496] = { let __args: [G; IN_496] = [__v_7, __v_1, __v_10, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_496] = []; + record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_496] = []; + record.function_queries[496].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_497: usize = 5; +const IN_497: usize = 5; +const OUT_497: usize = 0; +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 = inp[0]; + let __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_501] = { let __args: [G; IN_501] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_497] = []; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_0, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_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]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + match __v_7.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_8, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + if (__v_11 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 3] = [__v_13, __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_497] = { let __args: [G; IN_497] = [__v_9, __v_1, __v_14, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[497].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_497] = unsafe { *(result.output.as_ptr() as *const [G; OUT_497]) }; __ret } else { aiur_fn_497(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_497] = []; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_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 }; + 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() { + 2u64 => { + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + match __v_17.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_497] = []; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = __loaded[3]; + let __v_23: G = __loaded[4]; + let __v_24: G = __loaded[5]; + let __v_25: G = __loaded[6]; + let __v_26: G = __loaded[7]; + let __v_27: G = __loaded[8]; + let __v_28: G = __loaded[9]; + let __v_29: G = __loaded[10]; + match __v_19.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_12, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_30, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = G::from_u64(0); + if (__v_31 != __v_32) { + return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_32.as_canonical_u64() }); + } + let __r_arr: [G; OUT_503] = { let __args: [G; IN_503] = [__v_1, __v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[503].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_503] = unsafe { *(result.output.as_ptr() as *const [G; OUT_503]) }; __ret } else { aiur_fn_503(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_24, __v_12, __v_33, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_497] = []; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + 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() }); + } + let __ret: [G; OUT_497] = []; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(1); + if (__v_17 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); + } + let __ret: [G; OUT_497] = []; + record.function_queries[497].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }) +} + +const INPUT_SIZE_498: usize = 2; +const IN_498: usize = 2; +const OUT_498: usize = 1; +fn aiur_fn_498( + inp: [G; IN_498], + 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 = 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(0); + let __ret: [G; OUT_498] = [__v_5]; + record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = (__v_3 - __v_1); + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_498] = [__v_6]; + record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_498] = [__v_6]; + record.function_queries[498].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_499: usize = 4; +const IN_499: usize = 4; +const OUT_499: usize = 1; +fn aiur_fn_499( + inp: [G; IN_499], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_499], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + 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_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_499] = [__v_7]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __v_14: G = __loaded[6]; + let __v_15: G = __loaded[7]; + let __v_16: G = __loaded[8]; + let __v_17: G = __loaded[9]; + let __v_18: G = __loaded[10]; + match __v_8.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_19, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __v_21: G = G::from_u64(1); + let __ret: [G; OUT_499] = [__v_21]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_499] = [__v_21]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_499] = [__v_19]; + record.function_queries[499].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_500: usize = 2; +const IN_500: usize = 2; +const OUT_500: usize = 1; +fn aiur_fn_500( + inp: [G; IN_500], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_500], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_500] = [__v_7]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_500] = { let __args: [G; IN_500] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[500].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_500] = unsafe { *(result.output.as_ptr() as *const [G; OUT_500]) }; __ret } else { aiur_fn_500(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_500] = [__v_7]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_500] = [__v_6]; + record.function_queries[500].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_501: usize = 2; +const IN_501: usize = 2; +const OUT_501: usize = 1; +fn aiur_fn_501( + inp: [G; IN_501], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_501], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + 4u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + 5u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + 6u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_501] = [__v_7]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __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_501] = [__v_8]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_501] = [__v_8]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + 7u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_501] = [__v_6]; + record.function_queries[501].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_502: usize = 2; +const IN_502: usize = 2; +const OUT_502: usize = 1; +fn aiur_fn_502( + inp: [G; IN_502], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_502], 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(0); + let __ret: [G; OUT_502] = [__v_5]; + record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_501] = { let __args: [G; IN_501] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[501].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_501] = unsafe { *(result.output.as_ptr() as *const [G; OUT_501]) }; __ret } else { aiur_fn_501(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_502] = [__v_6]; + record.function_queries[502].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_502] = [__v_6]; + record.function_queries[502].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_503: usize = 3; +const IN_503: usize = 3; +const OUT_503: usize = 1; +fn aiur_fn_503( + inp: [G; IN_503], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_503], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_503] = [__v_4]; + record.function_queries[503].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_504: usize = 4; +const IN_504: usize = 4; +const OUT_504: usize = 1; +fn aiur_fn_504( + inp: [G; IN_504], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_504], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __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_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_504] = [__v_0]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + match __v_7.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_17, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = { let __values: [G; 32] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_1, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = (__v_19 - __v_53); + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = G::from_u64(1); + let __v_57: G = (__v_56 - __v_55); + let __v_58: G = (__v_54 * __v_57); + let __v_59: G = (__v_18 * __v_58); + match __v_59.as_canonical_u64() { + 1u64 => { + let __v_60: G = G::from_u64(0); + let __v_61: G = { let __values: [G; 3] = [__v_60, __v_3, __v_0]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_62: G = G::from_u64(1); + let __v_63: G = (__v_3 + __v_62); + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_61, __v_1, __v_6, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __ret: [G; OUT_504] = [__v_64]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_60: G = G::from_u64(1); + let __v_61: G = (__v_3 + __v_60); + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_6, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __ret: [G; OUT_504] = [__v_62]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_59.as_canonical_u64())); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_3 + __v_18); + let __r_arr: [G; OUT_504] = { let __args: [G; IN_504] = [__v_0, __v_1, __v_6, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[504].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_504] = unsafe { *(result.output.as_ptr() as *const [G; OUT_504]) }; __ret } else { aiur_fn_504(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_504] = [__v_20]; + record.function_queries[504].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_505: usize = 5; +const IN_505: usize = 5; +const OUT_505: usize = 0; +fn aiur_fn_505( + inp: [G; IN_505], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_505], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_505] = []; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 6u64 => { + 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_495] = { let __args: [G; IN_495] = [__v_11, __v_14, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[495].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_495] = unsafe { *(result.output.as_ptr() as *const [G; OUT_495]) }; __ret } else { aiur_fn_495(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __r_arr: [G; OUT_496] = { let __args: [G; IN_496] = [__v_23, __v_2, __v_24, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[496].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_496] = unsafe { *(result.output.as_ptr() as *const [G; OUT_496]) }; __ret } else { aiur_fn_496(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_505] = []; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_505] = { let __args: [G; IN_505] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[505].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_505] = unsafe { *(result.output.as_ptr() as *const [G; OUT_505]) }; __ret } else { aiur_fn_505(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_505] = []; + record.function_queries[505].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_506: usize = 2; +const IN_506: usize = 2; +const OUT_506: usize = 1; +fn aiur_fn_506( + inp: [G; IN_506], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_506], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_506] = [__v_6]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_506] = [__v_6]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_6: G = (__v_3 - __v_1); + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_506] = [__v_7]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_506] = [__v_7]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_506] = [__v_8]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_506] = [__v_8]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_506] = [__v_8]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_9] = { let __args: [G; IN_9] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[9].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_9] = unsafe { *(result.output.as_ptr() as *const [G; OUT_9]) }; __ret } else { aiur_fn_9(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_506] = [__v_10]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_506] = [__v_6]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_506] = { let __args: [G; IN_506] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[506].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_506] = unsafe { *(result.output.as_ptr() as *const [G; OUT_506]) }; __ret } else { aiur_fn_506(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_506] = [__v_6]; + record.function_queries[506].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_507: usize = 6; +const IN_507: usize = 6; +const OUT_507: usize = 1; +fn aiur_fn_507( + inp: [G; IN_507], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_507], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __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_201] = { let __args: [G; IN_201] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[201].get_mut(&__args[..]) { 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_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_507] = [__v_7]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_7: G = __r_arr[0]; + match __v_7.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_507] = [__v_8]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + let __v_15: G = __loaded[4]; + let __v_16: G = __loaded[5]; + let __v_17: G = __loaded[6]; + let __v_18: G = __loaded[7]; + let __v_19: G = __loaded[8]; + let __v_20: G = __loaded[9]; + let __v_21: G = __loaded[10]; + match __v_11.as_canonical_u64() { + 6u64 => { + match __v_17.as_canonical_u64() { + 0u64 => { + let __v_22: G = G::from_u64(1); + let __ret: [G; OUT_507] = [__v_22]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_13, __v_16, __v_17, __v_24, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_507] = [__v_25]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_507] = [__v_8]; + record.function_queries[507].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_508: usize = 6; +const IN_508: usize = 6; +const OUT_508: usize = 1; +fn aiur_fn_508( + inp: [G; IN_508], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_508], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_0, __v_2, __v_6, __v_3, __v_4, __v_5, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_508] = [__v_10]; + record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 3] = [__v_10, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_1 - __v_12); + let __r_arr: [G; OUT_508] = { let __args: [G; IN_508] = [__v_8, __v_13, __v_2, __v_11, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[508].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_508] = unsafe { *(result.output.as_ptr() as *const [G; OUT_508]) }; __ret } else { aiur_fn_508(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_508] = [__v_14]; + record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_10: G = G::from_u64(0); + let __ret: [G; OUT_508] = [__v_10]; + record.function_queries[508].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_509: usize = 7; +const IN_509: usize = 7; +const OUT_509: usize = 1; +fn aiur_fn_509( + inp: [G; IN_509], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_509], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = (__v_1 - __v_2); + match __v_7.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_509] = [__v_10]; + record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + match __v_8.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_9, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = G::from_u64(1); + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; + let __v_20: G = (__v_13 - __v_19); + let __v_21: G = G::from_u64(1); + let __v_22: G = (__v_21 - __v_2); + let __v_23: G = (__v_1 - __v_22); + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_20.as_canonical_u64() { + 0u64 => { + break '__mc_0 [__v_6]; + }, + _ => { + let __v_24: G = G::from_u64(0); + let __v_25: G = { let __values: [G; 3] = [__v_24, __v_23, __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 } }; + break '__mc_0 [__v_25]; + }, +} + }; + let __v_24: G = __mc_out___mc_0[0]; + let __v_25: G = G::from_u64(0); + let __v_26: G = { let __values: [G; 3] = [__v_25, __v_9, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_27: G = G::from_u64(1); + let __v_28: G = (__v_2 + __v_27); + let __r_arr: [G; OUT_509] = { let __args: [G; IN_509] = [__v_10, __v_1, __v_28, __v_26, __v_4, __v_5, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[509].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_509] = unsafe { *(result.output.as_ptr() as *const [G; OUT_509]) }; __ret } else { aiur_fn_509(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_509] = [__v_29]; + record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_509] = [__v_12]; + record.function_queries[509].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_510: usize = 2; +const IN_510: usize = 2; +const OUT_510: usize = 1; +fn aiur_fn_510( + inp: [G; IN_510], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_510], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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 __ret: [G; OUT_510] = [__v_5]; + record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_510] = [__v_6]; + record.function_queries[510].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_510] = { let __args: [G; IN_510] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[510].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_510] = unsafe { *(result.output.as_ptr() as *const [G; OUT_510]) }; __ret } else { aiur_fn_510(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_510] = [__v_6]; + record.function_queries[510].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_511: usize = 2; +const IN_511: usize = 2; +const OUT_511: usize = 1; +fn aiur_fn_511( + inp: [G; IN_511], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_511], 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(0); + let __ret: [G; OUT_511] = [__v_5]; + record.function_queries[511].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_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_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_9: G = (__v_6 - __v_1); + match __v_9.as_canonical_u64() { + 0u64 => { + let __v_10: G = G::from_u64(1); + let __ret: [G; OUT_511] = [__v_10]; + record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_511] = { let __args: [G; IN_511] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_511] = [__v_10]; + 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] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[511].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_511] = unsafe { *(result.output.as_ptr() as *const [G; OUT_511]) }; __ret } else { aiur_fn_511(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_511] = [__v_9]; + record.function_queries[511].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_512: usize = 11; +const IN_512: usize = 11; +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 = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_515] = { let __args: [G; IN_515] = [__v_11, __v_2, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_521] = { let __args: [G; IN_521] = [__v_13, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = G::from_u64(2); + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 4] = [__v_15, __v_0, __v_4, __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 __r_arr: [G; OUT_513] = { let __args: [G; IN_513] = [__v_17, __v_8, __v_3, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[513].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_513] = unsafe { *(result.output.as_ptr() as *const [G; OUT_513]) }; __ret } else { aiur_fn_513(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_18, __v_3, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = G::from_u64(1); + let __v_22: 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_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 4] = [__v_21, __v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = G::from_u64(5); + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 4] = [__v_25, __v_20, __v_24, __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 __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_27, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __ret: [G; OUT_512] = [__v_28]; + record.function_queries[512].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_513: usize = 5; +const IN_513: usize = 5; +const OUT_513: usize = 1; +fn aiur_fn_513( + inp: [G; IN_513], + 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 = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_0, __v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_513] = [__v_6]; + record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_513] = [__v_5]; + record.function_queries[513].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_514: usize = 3; +const IN_514: usize = 3; +const OUT_514: usize = 1; +fn aiur_fn_514( + inp: [G; IN_514], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_514], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_514] = [__v_0]; + record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_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_514] = { let __args: [G; IN_514] = [__v_10, __v_5, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_514] = [__v_11]; + record.function_queries[514].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_515: usize = 6; +const IN_515: usize = 6; +const OUT_515: usize = 1; +fn aiur_fn_515( + inp: [G; IN_515], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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 __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_515] = [__v_0]; + record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_516] = { let __args: [G; IN_516] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[516].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_516] = unsafe { *(result.output.as_ptr() as *const [G; OUT_516]) }; __ret } else { aiur_fn_516(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_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_515] = { let __args: [G; IN_515] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[515].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_515] = unsafe { *(result.output.as_ptr() as *const [G; OUT_515]) }; __ret } else { aiur_fn_515(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_515] = [__v_17]; + record.function_queries[515].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_516: usize = 4; +const IN_516: usize = 4; +const OUT_516: usize = 1; +fn aiur_fn_516( + inp: [G; IN_516], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_516], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + 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(0); + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_1 - __v_5); + let __v_7: G = (__v_6 - __v_0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_516] = [__v_9]; + record.function_queries[516].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_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_718] = { let __args: [G; IN_718] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_516] = [__v_6]; + record.function_queries[516].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(1); + let __v_8: G = (__v_1 - __v_7); + let __v_9: G = (__v_8 - __v_0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_516] = [__v_11]; + record.function_queries[516].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 = 1; +fn aiur_fn_517( + inp: [G; IN_517], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_517] = [__v_4]; + record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_0, __v_1, __v_4, __v_5, __v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_517] = [__v_7]; + record.function_queries[517].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_518: usize = 2; +const IN_518: usize = 2; +const OUT_518: usize = 1; +fn aiur_fn_518( + inp: [G; IN_518], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_518], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + match __v_3.as_canonical_u64() { + 6u64 => { + let __ret: [G; OUT_518] = [__v_8]; + record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_518] = [__v_14]; + record.function_queries[518].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_519: usize = 6; +const IN_519: usize = 6; +const OUT_519: usize = 1; +fn aiur_fn_519( + inp: [G; IN_519], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_519], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_519] = [__v_0]; + record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_520] = { let __args: [G; IN_520] = [__v_5, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[520].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_520] = unsafe { *(result.output.as_ptr() as *const [G; OUT_520]) }; __ret } else { aiur_fn_520(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_8, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_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_519] = { let __args: [G; IN_519] = [__v_12, __v_14, __v_2, __v_3, __v_4, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_519] = [__v_17]; + record.function_queries[519].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_520: usize = 4; +const IN_520: usize = 4; +const OUT_520: usize = 1; +fn aiur_fn_520( + inp: [G; IN_520], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_1 - __v_5); + let __v_7: G = (__v_6 - __v_0); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_520] = [__v_9]; + record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_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_718] = { let __args: [G; IN_718] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_6, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_520] = [__v_8]; + record.function_queries[520].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(1); + let __v_8: G = (__v_1 - __v_7); + let __v_9: G = (__v_8 - __v_0); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_6, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_520] = [__v_11]; + record.function_queries[520].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_521: usize = 2; +const IN_521: usize = 2; +const OUT_521: usize = 1; +fn aiur_fn_521( + inp: [G; IN_521], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_521], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_521] = [__v_4]; + record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 5u64 => { + let __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_521] = { let __args: [G; IN_521] = [__v_4, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[521].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_521] = unsafe { *(result.output.as_ptr() as *const [G; OUT_521]) }; __ret } else { aiur_fn_521(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = { let __values: [G; 3] = [__v_6, __v_3, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_521] = [__v_10]; + record.function_queries[521].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_522: usize = 3; +const IN_522: usize = 3; +const OUT_522: usize = 1; +fn aiur_fn_522( + inp: [G; IN_522], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_522], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = (__v_1 - __v_2); + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } 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_6]; + record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(4); + let __v_6: G = (__v_0 + __v_2); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 3] = [__v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 + __v_9); + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_0, __v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = { let __values: [G; 3] = [__v_4, __v_8, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_522] = [__v_12]; + record.function_queries[522].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_523: usize = 4; +const IN_523: usize = 4; +const OUT_523: usize = 1; +fn aiur_fn_523( + inp: [G; IN_523], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_523], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = (__v_1 - __v_3); + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_523] = [__v_0]; + record.function_queries[523].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + 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 __v_8: G = (__v_7 - __v_3); + let __v_9: G = (__v_8 + __v_2); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_5, __v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = G::from_u64(3); + let __v_13: G = G::from_u64(0); + let __v_14: G = { let __values: [G; 4] = [__v_12, __v_0, __v_11, __v_13]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_15: G = G::from_u64(1); + let __v_16: G = (__v_3 + __v_15); + let __r_arr: [G; OUT_523] = { let __args: [G; IN_523] = [__v_14, __v_1, __v_2, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[523].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_523] = unsafe { *(result.output.as_ptr() as *const [G; OUT_523]) }; __ret } else { aiur_fn_523(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __ret: [G; OUT_523] = [__v_17]; + record.function_queries[523].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 = 1; +fn aiur_fn_524( + inp: [G; IN_524], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_524], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = (__v_1 - __v_2); + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_524] = [__v_0]; + record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + let __v_6: G = (__v_1 - __v_5); + let __v_7: G = (__v_6 - __v_2); + let __v_8: G = G::from_u64(0); + let __v_9: G = { let __values: [G; 4] = [__v_4, __v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_10: G = G::from_u64(3); + let __v_11: G = G::from_u64(0); + let __v_12: G = { let __values: [G; 4] = [__v_10, __v_0, __v_9, __v_11]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(1); + let __v_14: G = (__v_2 + __v_13); + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_12, __v_1, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_524] = [__v_15]; + record.function_queries[524].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +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_525], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_525] = [__v_0]; + record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(5); + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_3, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_525] = [__v_8]; + record.function_queries[525].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_526: usize = 14; +const IN_526: usize = 14; +const OUT_526: usize = 1; +fn aiur_fn_526( + inp: [G; IN_526], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_526], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = (__v_9 + __v_10); + let __v_16: G = (__v_8 + __v_15); + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_519] = { let __args: [G; IN_519] = [__v_14, __v_17, __v_16, __v_3, __v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[519].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_519] = unsafe { *(result.output.as_ptr() as *const [G; OUT_519]) }; __ret } else { aiur_fn_519(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_6, __v_0, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + 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 = G::from_u64(1); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 3] = [__v_26, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_29: G = G::from_u64(1); + let __v_30: G = G::from_u64(1); + let __v_31: G = { let __values: [G; 3] = [__v_29, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = G::from_u64(1); + let __v_33: G = G::from_u64(1); + let __v_34: G = { let __values: [G; 3] = [__v_32, __v_33, __v_33]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_35: G = G::from_u64(0); + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_19, __v_6, __v_25, __v_28, __v_31, __v_34, __v_12, __v_13, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __v_37: G = __r_arr[1]; + let __v_38: G = __r_arr[2]; + let __v_39: G = __r_arr[3]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_40: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_41: G = __r_arr[0]; + let __v_42: G = (__v_40 + __v_41); + let __v_43: G = (__v_16 + __v_42); + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_45, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __v_47: G = G::from_u64(0); + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_46, __v_41, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __v_49: G = G::from_u64(1); + let __v_50: G = (__v_43 - __v_49); + let __v_51: G = (__v_11 + __v_22); + let __v_52: G = (__v_50 - __v_51); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = { let __values: [G; 4] = [__v_53, __v_52, __v_54, __v_54]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_55, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = G::from_u64(2); + let __v_58: G = G::from_u64(0); + let __v_59: G = { let __values: [G; 4] = [__v_57, __v_1, __v_5, __v_58]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_527] = { let __args: [G; IN_527] = [__v_59, __v_17, __v_8, __v_43, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[527].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_527] = unsafe { *(result.output.as_ptr() as *const [G; OUT_527]) }; __ret } else { aiur_fn_527(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __v_61: G = G::from_u64(0); + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_60, __v_40, __v_42, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __v_63: G = G::from_u64(3); + let __v_64: G = G::from_u64(0); + let __v_65: G = { let __values: [G; 4] = [__v_63, __v_56, __v_62, __v_64]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_66: G = G::from_u64(1); + let __v_67: G = G::from_u64(1); + let __v_68: G = { let __values: [G; 3] = [__v_66, __v_67, __v_67]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = G::from_u64(0); + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_37, __v_38, __v_36, __v_7, __v_11, __v_40, __v_16, __v_68, __v_12, __v_13, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __v_70: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_65, __v_70]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_71, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_72: G = __r_arr[0]; + let __ret: [G; OUT_526] = [__v_72]; + record.function_queries[526].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_527: usize = 6; +const IN_527: usize = 6; +const OUT_527: usize = 1; +fn aiur_fn_527( + inp: [G; IN_527], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_527], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_3 - __v_6); + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_0, __v_2, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_527] = [__v_9]; + record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_527] = [__v_6]; + record.function_queries[527].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_528: usize = 4; +const IN_528: usize = 4; +const OUT_528: usize = 1; +fn aiur_fn_528( + inp: [G; IN_528], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_528], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_528] = [__v_0]; + record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 5u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(1); + let __v_10: G = (__v_2 - __v_9); + let __v_11: G = (__v_10 - __v_3); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_8, __v_11, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_1 - __v_16); + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_3 + __v_18); + let __r_arr: [G; OUT_528] = { let __args: [G; IN_528] = [__v_15, __v_17, __v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[528].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_528] = unsafe { *(result.output.as_ptr() as *const [G; OUT_528]) }; __ret } else { aiur_fn_528(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_528] = [__v_20]; + record.function_queries[528].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_529: usize = 9; +const IN_529: usize = 9; +const OUT_529: usize = 4; +fn aiur_fn_529( + inp: [G; IN_529], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_529], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + 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_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_533] = { let __args: [G; IN_533] = [__v_10, __v_1, __v_5, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[533].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_533] = unsafe { *(result.output.as_ptr() as *const [G; OUT_533]) }; __ret } else { aiur_fn_533(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __v_15: G = G::from_u64(0); + let __v_16: G = { let __values: [G; 3] = [__v_15, __v_10, __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_17: G = G::from_u64(0); + let __v_18: G = { let __values: [G; 3] = [__v_17, __v_10, __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 } }; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_19: G = G::from_u64(0); + let __v_20: G = { let __values: [G; 3] = [__v_19, __v_8, __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_21: G = G::from_u64(0); + let __v_22: G = { let __values: [G; 3] = [__v_21, __v_14, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_23: G = G::from_u64(1); + let __v_24: G = (__v_8 + __v_23); + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_1, __v_16, __v_20, __v_22, __v_18, __v_6, __v_7, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + let __v_27: G = __r_arr[2]; + let __v_28: G = __r_arr[3]; + let __ret: [G; OUT_529] = [__v_25, __v_26, __v_27, __v_28]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_19: G = G::from_u64(1); + let __v_20: G = (__v_8 + __v_19); + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_11, __v_1, __v_16, __v_3, __v_4, __v_18, __v_6, __v_7, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __v_23: G = __r_arr[2]; + let __v_24: G = __r_arr[3]; + let __ret: [G; OUT_529] = [__v_21, __v_22, __v_23, __v_24]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_529] = [__v_13, __v_14, __v_15, __v_0]; + record.function_queries[529].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_530: usize = 2; +const IN_530: usize = 2; +const OUT_530: usize = 1; +fn aiur_fn_530( + inp: [G; IN_530], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_530], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + match __v_3.as_canonical_u64() { + 5u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 32] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + match __v_47.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(1); + let __v_50: G = G::from_u64(1); + let __v_51: G = { let __values: [G; 3] = [__v_49, __v_50, __v_50]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_52: G = { let __values: [G; 3] = [__v_48, __v_0, __v_51]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_530] = [__v_52]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_13, __v_1, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __ret: [G; OUT_530] = [__v_49]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_47.as_canonical_u64())); + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 3] = [__v_15, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = { let __values: [G; 3] = [__v_14, __v_0, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_530] = [__v_18]; + record.function_queries[530].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_531: usize = 3; +const IN_531: usize = 3; +const OUT_531: usize = 1; +fn aiur_fn_531( + inp: [G; IN_531], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_531], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(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_531] = [__v_8]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + let __v_11: G = __loaded[5]; + let __v_12: G = __loaded[6]; + let __v_13: G = __loaded[7]; + let __v_14: G = __loaded[8]; + let __v_15: G = __loaded[9]; + let __v_16: G = __loaded[10]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + match __v_17.as_canonical_u64() { + 1u64 => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(1); + let __v_20: G = (__v_2 + __v_19); + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_5, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = { let __values: [G; 3] = [__v_18, __v_2, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_531] = [__v_22]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_2 + __v_18); + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_5, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_531] = [__v_20]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + let __v_17: G = G::from_u64(1); + let __v_18: G = (__v_2 + __v_17); + let __r_arr: [G; OUT_531] = { let __args: [G; IN_531] = [__v_0, __v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[531].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_531] = unsafe { *(result.output.as_ptr() as *const [G; OUT_531]) }; __ret } else { aiur_fn_531(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_531] = [__v_19]; + record.function_queries[531].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_532: usize = 3; +const IN_532: usize = 3; +const OUT_532: usize = 1; +fn aiur_fn_532( + inp: [G; IN_532], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_532], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + 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]; + let __v_10: G = __loaded[6]; + let __v_11: G = __loaded[7]; + let __v_12: G = __loaded[8]; + let __v_13: G = __loaded[9]; + let __v_14: G = __loaded[10]; + match __v_4.as_canonical_u64() { + 5u64 => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = { let __values: [G; 32] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + match __v_48.as_canonical_u64() { + 1u64 => { + let __v_49: G = G::from_u64(0); + let __ret: [G; OUT_532] = [__v_49]; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_49.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_50: G = __loaded[0]; + let __v_51: G = __loaded[1]; + let __v_52: G = __loaded[2]; + let __v_53: G = __loaded[3]; + let __v_54: G = __loaded[4]; + let __v_55: G = __loaded[5]; + let __v_56: G = __loaded[6]; + let __v_57: G = __loaded[7]; + let __v_58: G = __loaded[8]; + let __v_59: G = __loaded[9]; + let __v_60: G = __loaded[10]; + match __v_50.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_60, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __ret: [G; OUT_532] = [__v_61]; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_61: G = G::from_u64(0); + let __ret: [G; OUT_532] = [__v_61]; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_48.as_canonical_u64())); + }, + } + }, + _ => { + let __v_15: G = G::from_u64(0); + let __ret: [G; OUT_532] = [__v_15]; + record.function_queries[532].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_533: usize = 5; +const IN_533: usize = 5; +const OUT_533: usize = 2; +fn aiur_fn_533( + inp: [G; IN_533], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_533], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_7, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_6, __v_8, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_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 }; + let __v_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __v_15: G = __loaded[3]; + match __v_12.as_canonical_u64() { + 2u64 => { + let __v_16: G = G::from_u64(0); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_1, __v_13, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __ret: [G; OUT_533] = [__v_17, __v_18]; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __ret: [G; OUT_533] = [__v_16, __v_17]; + record.function_queries[533].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +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_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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __ret: [G; OUT_534] = [__v_6, __v_7]; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = (__v_4 - __v_1); + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(1); + let __ret: [G; OUT_534] = [__v_7, __v_2]; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_2 + __v_7); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_5, __v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_534] = [__v_9, __v_10]; + record.function_queries[534].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_535: usize = 1; +const IN_535: usize = 1; +const OUT_535: usize = 2; +fn aiur_fn_535( + inp: [G; IN_535], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_535], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = 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_536] = { let __args: [G; IN_536] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[536].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_536] = unsafe { *(result.output.as_ptr() as *const [G; OUT_536]) }; __ret } else { aiur_fn_536(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_535] = [__v_6, __v_5]; + record.function_queries[535].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 = 2; +fn aiur_fn_536( + inp: [G; IN_536], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 5u64 => { + let __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_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 !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_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __ret: [G; OUT_536] = [__v_8, __v_9]; + record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_536] = [__v_1, __v_0]; + record.function_queries[536].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_537: usize = 3; +const IN_537: usize = 3; +const OUT_537: usize = 1; +fn aiur_fn_537( + inp: [G; IN_537], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + 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_537] = [__v_8]; + record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_537] = { let __args: [G; IN_537] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[537].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_537] = unsafe { *(result.output.as_ptr() as *const [G; OUT_537]) }; __ret } else { aiur_fn_537(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { 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_537] = [__v_9]; + record.function_queries[537].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_538: usize = 4; +const IN_538: usize = 4; +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_538], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = (__v_1 - __v_3); + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_538] = [__v_0]; + record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = (__v_2 - __v_3); + let __v_7: G = G::from_u64(0); + let __v_8: G = { let __values: [G; 4] = [__v_5, __v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = G::from_u64(3); + let __v_10: G = G::from_u64(0); + let __v_11: G = { let __values: [G; 4] = [__v_9, __v_0, __v_8, __v_10]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_3 + __v_12); + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_11, __v_1, __v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_538] = [__v_14]; + record.function_queries[538].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_539: usize = 4; +const IN_539: usize = 4; +const OUT_539: usize = 1; +fn aiur_fn_539( + inp: [G; IN_539], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_539], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = (__v_1 - __v_3); + match __v_4.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_539] = [__v_0]; + record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_2 - __v_6); + let __v_8: G = (__v_7 - __v_3); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_5, __v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(3); + let __v_12: G = G::from_u64(0); + let __v_13: G = { let __values: [G; 4] = [__v_11, __v_0, __v_10, __v_12]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_14: G = G::from_u64(1); + let __v_15: G = (__v_3 + __v_14); + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_13, __v_1, __v_2, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_539] = [__v_16]; + record.function_queries[539].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_540: usize = 2; +const IN_540: usize = 2; +const OUT_540: usize = 2; +fn aiur_fn_540( + inp: [G; IN_540], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_540], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = 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_541] = { let __args: [G; IN_541] = [__v_0, __v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __v_6: G = __r_arr[1]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_540] = [__v_7, __v_6]; + record.function_queries[540].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_541: usize = 3; +const IN_541: usize = 3; +const OUT_541: usize = 2; +fn aiur_fn_541( + inp: [G; IN_541], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_541], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_541] = [__v_2, __v_0]; + record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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() { + 5u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_1 - __v_7); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 3] = [__v_9, __v_4, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_541] = { let __args: [G; IN_541] = [__v_5, __v_8, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[541].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_541] = unsafe { *(result.output.as_ptr() as *const [G; OUT_541]) }; __ret } else { aiur_fn_541(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __ret: [G; OUT_541] = [__v_11, __v_12]; + record.function_queries[541].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_542: usize = 3; +const IN_542: usize = 3; +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_542], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = (__v_1 - __v_2); + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_542] = [__v_0]; + record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_4: G = G::from_u64(0); + let __v_5: G = (__v_1 - __v_2); + let __v_6: G = G::from_u64(0); + let __v_7: G = { let __values: [G; 4] = [__v_4, __v_5, __v_6, __v_6]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_8: G = G::from_u64(3); + let __v_9: G = G::from_u64(0); + let __v_10: G = { let __values: [G; 4] = [__v_8, __v_0, __v_7, __v_9]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_2 + __v_11); + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_10, __v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __ret: [G; OUT_542] = [__v_13]; + record.function_queries[542].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_543: usize = 13; +const IN_543: usize = 13; +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_543], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + match __v_13.as_canonical_u64() { + 1u64 => { + let __v_16: G = G::from_u64(1); + let __v_17: G = G::from_u64(1); + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_543] = [__v_18]; + record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_10, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + let __v_21: G = __loaded[4]; + let __v_22: G = __loaded[5]; + let __v_23: G = __loaded[6]; + let __v_24: G = __loaded[7]; + let __v_25: G = __loaded[8]; + let __v_26: G = __loaded[9]; + let __v_27: G = __loaded[10]; + match __v_17.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_526] = { let __args: [G; IN_526] = [__v_1, __v_14, __v_19, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_12, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[526].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_526] = unsafe { *(result.output.as_ptr() as *const [G; OUT_526]) }; __ret } else { aiur_fn_526(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = G::from_u64(1); + let __v_30: G = (__v_12 + __v_29); + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = G::from_u64(0); + let __v_33: G = { let __values: [G; 3] = [__v_32, __v_28, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_543] = [__v_33]; + record.function_queries[543].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_13.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_544: usize = 9; +const IN_544: usize = 9; +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_544], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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 __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__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[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_544] = [__v_10]; + record.function_queries[544].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_545: usize = 10; +const IN_545: usize = 10; +const OUT_545: usize = 1; +fn aiur_fn_545( + inp: [G; IN_545], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_545], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __loaded: [G; 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_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() { + 1u64 => { + let __v_16: G = G::from_u64(1); + let __v_17: G = G::from_u64(1); + let __v_18: G = { let __values: [G; 3] = [__v_16, __v_17, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_545] = [__v_18]; + record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_16.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + let __v_21: G = __loaded[4]; + let __v_22: G = __loaded[5]; + let __v_23: G = __loaded[6]; + let __v_24: G = __loaded[7]; + let __v_25: G = __loaded[8]; + let __v_26: G = __loaded[9]; + let __v_27: G = __loaded[10]; + match __v_17.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_512] = { let __args: [G; IN_512] = [__v_11, __v_19, __v_20, __v_21, __v_14, __v_3, __v_4, __v_5, __v_7, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[512].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_512] = unsafe { *(result.output.as_ptr() as *const [G; OUT_512]) }; __ret } else { aiur_fn_512(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_28, __v_9, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_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_9 + __v_32); + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_15, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __v_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_545] = [__v_35]; + record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_545] = { let __args: [G; IN_545] = [__v_15, __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[545].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_545] = unsafe { *(result.output.as_ptr() as *const [G; OUT_545]) }; __ret } else { aiur_fn_545(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __ret: [G; OUT_545] = [__v_28]; + record.function_queries[545].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_546: usize = 11; +const IN_546: usize = 11; +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_546], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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 __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + let __v_15: G = __loaded[4]; + let __v_16: G = __loaded[5]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_17: G = G::from_u64(1); + let __v_18: G = G::from_u64(1); + let __v_19: G = { let __values: [G; 3] = [__v_17, __v_18, __v_18]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_546] = [__v_19]; + record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + let __v_28: G = __loaded[10]; + match __v_18.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_543] = { let __args: [G; IN_543] = [__v_23, __v_12, __v_13, __v_14, __v_15, __v_1, __v_2, __v_3, __v_4, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[543].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_543] = unsafe { *(result.output.as_ptr() as *const [G; OUT_543]) }; __ret } else { aiur_fn_543(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_30: G = __r_arr[0]; + let __v_31: G = (__v_10 + __v_30); + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_29, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __ret: [G; OUT_546] = [__v_33]; + record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_16, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_546] = [__v_29]; + record.function_queries[546].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_547: usize = 10; +const IN_547: usize = 10; +const OUT_547: usize = 1; +fn aiur_fn_547( + inp: [G; IN_547], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_547], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = (__v_6 + __v_4); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_11, __v_12, __v_13, __v_2, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __mc_out___mc_0: [G; 3] = '__mc_0: { match __v_14.as_canonical_u64() { + 1u64 => { + let __v_15: G = G::from_u64(4); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + break '__mc_0 [__v_15, __v_16, __v_17]; + }, + 0u64 => { + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + break '__mc_0 [__v_15, __v_16, __v_16]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, +} + }; + let __v_15: G = __mc_out___mc_0[0]; + let __v_16: G = __mc_out___mc_0[1]; + let __v_17: G = __mc_out___mc_0[2]; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_18, __v_14, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_20, __v_0, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = __r_arr[1]; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_19, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = __r_arr[1]; + let __v_27: G = __r_arr[2]; + let __v_28: G = __r_arr[3]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_1, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_29, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_19, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_19, __v_3, __v_5, __v_15, __v_16, __v_17, __v_14, __v_3, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = G::from_u64(0); + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_19, __v_20, __v_32, __v_3, __v_21, __v_5, __v_14, __v_3, __v_8, __v_9, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_36: G = __r_arr[0]; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_31, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = (__v_21 + __v_36); + let __v_40: G = G::from_u64(0); + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_37, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = G::from_u64(0); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_20, __v_0, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = __r_arr[1]; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_19, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = __r_arr[1]; + let __v_47: G = __r_arr[2]; + let __v_48: G = __r_arr[3]; + let __v_49: G = G::from_u64(2); + let __v_50: G = G::from_u64(0); + let __v_51: G = { let __values: [G; 4] = [__v_49, __v_0, __v_48, __v_50]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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 = (__v_36 + __v_4); + let __v_53: G = (__v_21 + __v_52); + let __v_54: G = (__v_3 + __v_53); + let __v_55: G = G::from_u64(1); + let __v_56: G = (__v_54 - __v_55); + let __r_arr: [G; OUT_567] = { let __args: [G; IN_567] = [__v_51, __v_3, __v_56, __v_4, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[567].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_567] = unsafe { *(result.output.as_ptr() as *const [G; OUT_567]) }; __ret } else { aiur_fn_567(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = G::from_u64(0); + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_57, __v_4, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = G::from_u64(1); + let __v_61: G = (__v_54 + __v_60); + let __v_62: G = G::from_u64(1); + let __v_63: G = (__v_61 - __v_62); + let __v_64: G = (__v_3 + __v_44); + let __v_65: G = (__v_63 - __v_64); + let __v_66: G = G::from_u64(0); + let __v_67: G = G::from_u64(0); + let __v_68: G = { let __values: [G; 4] = [__v_66, __v_65, __v_67, __v_67]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_69: G = G::from_u64(0); + let __r_arr: [G; OUT_542] = { let __args: [G; IN_542] = [__v_68, __v_4, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[542].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_542] = unsafe { *(result.output.as_ptr() as *const [G; OUT_542]) }; __ret } else { aiur_fn_542(__args, record, io_buffer, __cu)? } }; + let __v_70: G = __r_arr[0]; + let __v_71: G = G::from_u64(3); + let __v_72: G = G::from_u64(0); + let __v_73: G = G::from_u64(0); + let __v_74: G = G::from_u64(0); + let __v_75: G = { let __values: [G; 4] = [__v_72, __v_73, __v_74, __v_74]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_76: G = G::from_u64(0); + let __v_77: G = { let __values: [G; 4] = [__v_71, __v_70, __v_75, __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 __v_78: G = G::from_u64(5); + let __v_79: G = G::from_u64(0); + let __v_80: G = { let __values: [G; 4] = [__v_78, __v_59, __v_77, __v_79]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_80, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_81: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_81, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_82: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_82, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_83: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_83, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __ret: [G; OUT_547] = [__v_84]; + record.function_queries[547].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_548: usize = 21; +const IN_548: usize = 21; +const OUT_548: usize = 1; +fn aiur_fn_548( + inp: [G; IN_548], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_548], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = (__v_8 + __v_9); + let __v_22: G = G::from_u64(0); + let __r_arr: [G; OUT_549] = { let __args: [G; IN_549] = [__v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_3, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_518] = { let __args: [G; IN_518] = [__v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[518].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_518] = unsafe { *(result.output.as_ptr() as *const [G; OUT_518]) }; __ret } else { aiur_fn_518(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_517] = { let __args: [G; IN_517] = [__v_24, __v_25, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[517].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_517] = unsafe { *(result.output.as_ptr() as *const [G; OUT_517]) }; __ret } else { aiur_fn_517(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = G::from_u64(1); + let __v_28: G = G::from_u64(1); + let __v_29: G = { let __values: [G; 3] = [__v_27, __v_28, __v_28]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_30: G = G::from_u64(1); + let __v_31: G = G::from_u64(1); + let __v_32: G = { let __values: [G; 3] = [__v_30, __v_31, __v_31]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_33: G = G::from_u64(1); + let __v_34: G = G::from_u64(1); + let __v_35: G = { let __values: [G; 3] = [__v_33, __v_34, __v_34]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(1); + let __v_37: G = G::from_u64(1); + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = G::from_u64(0); + let __r_arr: [G; OUT_529] = { let __args: [G; IN_529] = [__v_26, __v_14, __v_29, __v_32, __v_35, __v_38, __v_19, __v_20, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[529].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_529] = unsafe { *(result.output.as_ptr() as *const [G; OUT_529]) }; __ret } else { aiur_fn_529(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __v_41: G = __r_arr[1]; + let __v_42: G = __r_arr[2]; + let __v_43: G = __r_arr[3]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_44: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_45: G = __r_arr[0]; + let __v_46: G = (__v_7 + __v_44); + let __v_47: G = (__v_6 + __v_46); + let __v_48: G = (__v_5 + __v_47); + let __v_49: G = G::from_u64(1); + let __v_50: G = (__v_48 - __v_49); + let __v_51: G = (__v_6 + __v_4); + let __v_52: G = (__v_5 + __v_51); + let __v_53: G = (__v_50 - __v_52); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = { let __values: [G; 4] = [__v_54, __v_53, __v_55, __v_55]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_57: G = G::from_u64(0); + let __r_arr: [G; OUT_539] = { let __args: [G; IN_539] = [__v_56, __v_44, __v_44, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[539].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_539] = unsafe { *(result.output.as_ptr() as *const [G; OUT_539]) }; __ret } else { aiur_fn_539(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __v_59: G = G::from_u64(1); + let __v_60: G = G::from_u64(1); + let __v_61: G = { let __values: [G; 3] = [__v_59, __v_60, __v_60]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_62: G = G::from_u64(0); + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_58, __v_41, __v_42, __v_40, __v_13, __v_15, __v_5, __v_6, __v_7, __v_44, __v_23, __v_61, __v_19, __v_20, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __v_63: G = __r_arr[0]; + let __v_64: G = (__v_6 + __v_7); + let __v_65: G = G::from_u64(0); + let __r_arr: [G; OUT_557] = { let __args: [G; IN_557] = [__v_40, __v_64, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_63, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_67, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_68, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_69, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __v_70: G = __r_arr[0]; + let __ret: [G; OUT_548] = [__v_70]; + record.function_queries[548].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_549: usize = 2; +const IN_549: usize = 2; +const OUT_549: usize = 1; +fn aiur_fn_549( + inp: [G; IN_549], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_549], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = (__v_0 - __v_1); + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(1); + let __v_5: G = { let __values: [G; 3] = [__v_3, __v_4, __v_4]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_549] = [__v_5]; + record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(4); + let __v_5: G = G::from_u64(0); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_1, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_549] = { let __args: [G; IN_549] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[549].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_549] = unsafe { *(result.output.as_ptr() as *const [G; OUT_549]) }; __ret } else { aiur_fn_549(__args, record, io_buffer, __cu)? } }; + let __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_549] = [__v_10]; + record.function_queries[549].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_550: usize = 2; +const IN_550: usize = 2; +const OUT_550: usize = 1; +fn aiur_fn_550( + inp: [G; IN_550], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_550], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_550] = [__v_0]; + record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(4); + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __v_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_550] = [__v_8]; + record.function_queries[550].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_551: usize = 15; +const IN_551: usize = 15; +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_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 = inp[3]; + 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 __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_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + match __v_15.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_551] = [__v_0]; + record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = (__v_8 + __v_9); + let __v_22: G = (__v_7 + __v_21); + let __v_23: G = (__v_6 + __v_22); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = (__v_9 - __v_16); + let __v_26: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_24, __v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = (__v_7 + __v_8); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_27, __v_28, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_29, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_33, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_32, __v_34, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_36: G = __r_arr[0]; + let __v_37: G = (__v_23 + __v_36); + let __v_38: G = G::from_u64(2); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 4] = [__v_38, __v_19, __v_10, __v_39]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_41: G = G::from_u64(1); + let __v_42: G = (__v_37 - __v_41); + let __v_43: G = G::from_u64(0); + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_40, __v_6, __v_42, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = G::from_u64(1); + let __v_46: G = (__v_37 - __v_45); + let __v_47: G = (__v_46 - __v_6); + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_44, __v_7, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = G::from_u64(1); + let __v_51: G = (__v_37 - __v_50); + let __v_52: G = (__v_51 - __v_6); + let __v_53: G = (__v_52 - __v_7); + let __v_54: G = G::from_u64(0); + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_49, __v_8, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_57, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_55, __v_58]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __v_60: G = G::from_u64(1); + let __v_61: G = (__v_9 - __v_60); + let __v_62: G = (__v_61 - __v_16); + let __v_63: G = (__v_62 + __v_36); + let __v_64: G = G::from_u64(0); + let __v_65: G = G::from_u64(0); + let __v_66: G = { let __values: [G; 4] = [__v_64, __v_63, __v_65, __v_65]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_67: G = G::from_u64(0); + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_66, __v_36, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + let __v_69: G = G::from_u64(3); + let __v_70: G = G::from_u64(0); + let __v_71: G = { let __values: [G; 4] = [__v_69, __v_59, __v_68, __v_70]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_550] = { let __args: [G; IN_550] = [__v_71, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[550].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_550] = unsafe { *(result.output.as_ptr() as *const [G; OUT_550]) }; __ret } else { aiur_fn_550(__args, record, io_buffer, __cu)? } }; + let __v_72: G = __r_arr[0]; + let __v_73: G = G::from_u64(3); + let __v_74: G = G::from_u64(0); + let __v_75: G = { let __values: [G; 4] = [__v_73, __v_0, __v_72, __v_74]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_76: G = G::from_u64(1); + let __v_77: G = (__v_14 + __v_76); + let __r_arr: [G; OUT_551] = { let __args: [G; IN_551] = [__v_75, __v_17, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[551].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_551] = unsafe { *(result.output.as_ptr() as *const [G; OUT_551]) }; __ret } else { aiur_fn_551(__args, record, io_buffer, __cu)? } }; + let __v_78: G = __r_arr[0]; + let __ret: [G; OUT_551] = [__v_78]; + record.function_queries[551].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_15.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_552: usize = 7; +const IN_552: usize = 7; +const OUT_552: usize = 1; +fn aiur_fn_552( + inp: [G; IN_552], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_552], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = (__v_4 + __v_5); + let __v_8: G = (__v_3 + __v_7); + let __v_9: G = (__v_2 + __v_8); + let __r_arr: [G; OUT_486] = { let __args: [G; IN_486] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[486].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_486] = unsafe { *(result.output.as_ptr() as *const [G; OUT_486]) }; __ret } else { aiur_fn_486(__args, record, io_buffer, __cu)? } }; + let __v_10: 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_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 }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __v_14: G = __loaded[3]; + match __v_11.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_15: G = __r_arr[0]; + let __v_16: 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_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_17: G = __loaded[0]; + let __v_18: G = __loaded[1]; + let __v_19: G = __loaded[2]; + let __v_20: G = __loaded[3]; + match __v_17.as_canonical_u64() { + 2u64 => { + let __ret: [G; OUT_552] = [__v_18]; + record.function_queries[552].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_17.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_553: usize = 3; +const IN_553: usize = 3; +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_553], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(1); + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_3, __v_2, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_6, __v_2, __v_2, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_553] = [__v_8]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_553] = [__v_5]; + record.function_queries[553].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_554: usize = 6; +const IN_554: usize = 6; +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_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 = 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() { + 1u64 => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_554] = [__v_9]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_16, __v_11, __v_12, __v_14, __v_15, __v_13, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = (__v_20 - __v_0); + let __v_22: G = G::from_bool((__v_21 == G::ZERO)); + let __mc_out___mc_0: [G; 1] = '__mc_0: { match __v_2.as_canonical_u64() { + 0u64 => { + let __v_23: G = G::from_u64(1); + break '__mc_0 [__v_23]; + }, + _ => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + break '__mc_0 [__v_23]; + }, +} + }; + let __v_23: G = __mc_out___mc_0[0]; + let __v_24: G = (__v_22 * __v_23); + match __v_24.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_554] = [__v_5]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_25: G = G::from_u64(1); + let __v_26: G = (__v_5 + __v_25); + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __ret: [G; OUT_554] = [__v_27]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64())); + }, + } + }, + _ => { + let __v_20: G = G::from_u64(1); + let __v_21: G = (__v_5 + __v_20); + let __r_arr: [G; OUT_554] = { let __args: [G; IN_554] = [__v_0, __v_1, __v_2, __v_8, __v_4, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[554].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_554] = unsafe { *(result.output.as_ptr() as *const [G; OUT_554]) }; __ret } else { aiur_fn_554(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_554] = [__v_22]; + record.function_queries[554].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_555: usize = 3; +const IN_555: usize = 3; +const OUT_555: usize = 1; +fn aiur_fn_555( + inp: [G; IN_555], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_555], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_555] = [__v_8]; + record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_553] = { let __args: [G; IN_553] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[553].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_553] = unsafe { *(result.output.as_ptr() as *const [G; OUT_553]) }; __ret } else { aiur_fn_553(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __v_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_555] = [__v_9]; + record.function_queries[555].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +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_556], 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() { + 0u64 => { + match __v_3.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __v_14: G = __loaded[6]; + let __v_15: G = __loaded[7]; + let __v_16: G = __loaded[8]; + let __v_17: G = __loaded[9]; + let __v_18: G = __loaded[10]; + match __v_8.as_canonical_u64() { + 6u64 => { + let __ret: [G; OUT_556] = [__v_11]; + record.function_queries[556].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +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_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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_557] = [__v_8]; + record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __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_557] = { let __args: [G; IN_557] = [__v_5, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[557].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_557] = unsafe { *(result.output.as_ptr() as *const [G; OUT_557]) }; __ret } else { aiur_fn_557(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_6, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_557] = [__v_11]; + record.function_queries[557].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_558: usize = 4; +const IN_558: usize = 4; +const OUT_558: usize = 0; +fn aiur_fn_558( + inp: [G; IN_558], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_558], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __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_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __v_8: G = __loaded[4]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_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 __ret: [G; OUT_558] = []; + record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_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() { + 0u64 => { + match __v_5.as_canonical_u64() { + _ => { + match __v_10.as_canonical_u64() { + _ => { + if (__v_5 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_10.as_canonical_u64() }); + } + if (__v_6 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + 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_454] = { let __args: [G; IN_454] = [__v_7, __v_12, __v_16, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = G::from_u64(1); + if (__v_17 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); + } + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_8, __v_13, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_558] = []; + record.function_queries[558].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_559: usize = 13; +const IN_559: usize = 13; +const OUT_559: usize = 0; +fn aiur_fn_559( + inp: [G; IN_559], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_559], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + match __v_1.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_13.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = __loaded[3]; + let __v_18: G = __loaded[4]; + let __v_19: G = __loaded[5]; + let __v_20: G = __loaded[6]; + let __v_21: G = __loaded[7]; + let __v_22: G = __loaded[8]; + let __v_23: G = __loaded[9]; + let __v_24: G = __loaded[10]; + match __v_14.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_19, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + if (__v_25 != __v_0) { + return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_0.as_canonical_u64() }); + } + let __ret: [G; OUT_559] = []; + record.function_queries[559].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_14.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_560: usize = 2; +const IN_560: usize = 2; +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_560], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + match __v_3.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_15: G = __r_arr[0]; + let __v_16: G = G::from_u64(1); + let __v_17: G = (__v_15 - __v_16); + match __v_17.as_canonical_u64() { + 0u64 => { + let __v_18: G = (__v_6 + __v_7); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = __r_arr[1]; + let __v_21: G = __r_arr[2]; + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { 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_24: G = __r_arr[0]; + match __v_24.as_canonical_u64() { + 0u64 => { + let __v_25: G = G::from_u64(0); + let __ret: [G; OUT_560] = [__v_25]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(1); + let __v_27: G = (__v_25 - __v_26); + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_28: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_8, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_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: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_31: G = __loaded[0]; + let __v_32: G = __loaded[1]; + let __v_33: G = __loaded[2]; + let __v_34: G = __loaded[3]; + let __v_35: G = __loaded[4]; + let __v_36: G = __loaded[5]; + let __v_37: G = __loaded[6]; + let __v_38: G = __loaded[7]; + let __v_39: G = __loaded[8]; + let __v_40: G = __loaded[9]; + let __v_41: G = __loaded[10]; + match __v_31.as_canonical_u64() { + 6u64 => { + let __v_42: G = G::from_bool((__v_37 == G::ZERO)); + let __ret: [G; OUT_560] = [__v_42]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_42: G = G::from_u64(0); + let __ret: [G; OUT_560] = [__v_42]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_28: G = G::from_u64(0); + let __ret: [G; OUT_560] = [__v_28]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64())); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_560] = [__v_18]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_560] = [__v_14]; + record.function_queries[560].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_561: usize = 14; +const IN_561: usize = 14; +const OUT_561: usize = 0; +fn aiur_fn_561( + inp: [G; IN_561], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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 __v_3: G = inp[3]; + 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]; + match __v_1.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_8, __v_3, __v_4, __v_6, __v_7, __v_5, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_569] = { let __args: [G; IN_569] = [__v_14, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[569].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_569] = unsafe { *(result.output.as_ptr() as *const [G; OUT_569]) }; __ret } else { aiur_fn_569(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_560] = { let __args: [G; IN_560] = [__v_14, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[560].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_560] = unsafe { *(result.output.as_ptr() as *const [G; OUT_560]) }; __ret } else { aiur_fn_560(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + if (__v_9 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); + } + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_17.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_18: G = __loaded[0]; + let __v_19: G = __loaded[1]; + let __v_20: G = __loaded[2]; + let __v_21: G = __loaded[3]; + let __v_22: G = __loaded[4]; + let __v_23: G = __loaded[5]; + let __v_24: G = __loaded[6]; + let __v_25: G = __loaded[7]; + let __v_26: G = __loaded[8]; + let __v_27: G = __loaded[9]; + let __v_28: G = __loaded[10]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_29.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_30: G = __loaded[0]; + let __v_31: G = __loaded[1]; + let __v_32: G = __loaded[2]; + let __v_33: G = __loaded[3]; + let __v_34: G = __loaded[4]; + let __v_35: G = __loaded[5]; + let __v_36: G = __loaded[6]; + let __v_37: G = __loaded[7]; + let __v_38: G = __loaded[8]; + let __v_39: G = __loaded[9]; + let __v_40: G = __loaded[10]; + match __v_18.as_canonical_u64() { + 5u64 => { + match __v_30.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_547] = { let __args: [G; IN_547] = [__v_14, __v_32, __v_35, __v_21, __v_34, __v_19, __v_33, __v_15, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[547].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_547] = unsafe { *(result.output.as_ptr() as *const [G; OUT_547]) }; __ret } else { aiur_fn_547(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = G::from_u64(1); + let __v_43: G = G::from_u64(1); + let __v_44: G = { let __values: [G; 3] = [__v_42, __v_43, __v_43]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_3, __v_41, __v_44, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(1); + if (__v_45 != __v_46) { + return Err(ExecError::AssertEqMismatch { lhs: __v_45.as_canonical_u64(), rhs: __v_46.as_canonical_u64() }); + } + let __v_47: G = (__v_33 + __v_34); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_32, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_48: G = __r_arr[0]; + let __v_49: G = __r_arr[1]; + let __v_50: G = __r_arr[2]; + let __r_arr: [G; OUT_507] = { let __args: [G; IN_507] = [__v_48, __v_49, __v_50, __v_35, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[507].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_507] = unsafe { *(result.output.as_ptr() as *const [G; OUT_507]) }; __ret } else { aiur_fn_507(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __mc_out___mc_0: [G; 3] = '__mc_0: { match __v_51.as_canonical_u64() { + 1u64 => { + let __v_52: G = G::from_u64(4); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + break '__mc_0 [__v_52, __v_53, __v_54]; + }, + 0u64 => { + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + break '__mc_0 [__v_52, __v_53, __v_53]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_51.as_canonical_u64())); + }, +} + }; + let __v_52: G = __mc_out___mc_0[0]; + let __v_53: G = __mc_out___mc_0[1]; + let __v_54: G = __mc_out___mc_0[2]; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_15, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __r_arr: [G; OUT_562] = { let __args: [G; IN_562] = [__v_55, __v_51, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[562].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_562] = unsafe { *(result.output.as_ptr() as *const [G; OUT_562]) }; __ret } else { aiur_fn_562(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_56, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __v_59: G = __r_arr[0]; + let __r_arr: [G; OUT_544] = { let __args: [G; IN_544] = [__v_56, __v_21, __v_19, __v_52, __v_53, __v_54, __v_51, __v_21, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[544].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_544] = unsafe { *(result.output.as_ptr() as *const [G; OUT_544]) }; __ret } else { aiur_fn_544(__args, record, io_buffer, __cu)? } }; + let __v_60: G = __r_arr[0]; + let __v_61: G = G::from_u64(0); + let __r_arr: [G; OUT_546] = { let __args: [G; IN_546] = [__v_56, __v_57, __v_59, __v_21, __v_58, __v_19, __v_51, __v_21, __v_12, __v_13, __v_61]; let __cu = unconstrained; if let Some(result) = record.function_queries[546].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_546] = unsafe { *(result.output.as_ptr() as *const [G; OUT_546]) }; __ret } else { aiur_fn_546(__args, record, io_buffer, __cu)? } }; + let __v_62: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_63: G = __r_arr[0]; + let __v_64: G = G::from_u64(0); + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_57, __v_14, __v_12, __v_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __v_66: G = G::from_u64(0); + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_51, __v_19, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __r_arr: [G; OUT_233] = { let __args: [G; IN_233] = [__v_20, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[233].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_233] = unsafe { *(result.output.as_ptr() as *const [G; OUT_233]) }; __ret } else { aiur_fn_233(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_68, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __v_69: G = __r_arr[0]; + let __v_70: G = __r_arr[1]; + let __r_arr: [G; OUT_555] = { let __args: [G; IN_555] = [__v_57, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[555].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_555] = unsafe { *(result.output.as_ptr() as *const [G; OUT_555]) }; __ret } else { aiur_fn_555(__args, record, io_buffer, __cu)? } }; + let __v_71: G = __r_arr[0]; + let __v_72: G = G::from_u64(0); + let __r_arr: [G; OUT_534] = { let __args: [G; IN_534] = [__v_57, __v_14, __v_72]; let __cu = unconstrained; if let Some(result) = record.function_queries[534].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_534] = unsafe { *(result.output.as_ptr() as *const [G; OUT_534]) }; __ret } else { aiur_fn_534(__args, record, io_buffer, __cu)? } }; + let __v_73: G = __r_arr[0]; + let __v_74: G = __r_arr[1]; + let __r_arr: [G; OUT_566] = { let __args: [G; IN_566] = [__v_56, __v_74]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __v_75: G = __r_arr[0]; + let __v_76: G = __r_arr[1]; + let __v_77: G = __r_arr[2]; + let __v_78: G = __r_arr[3]; + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_14, __v_35, __v_21, __v_58, __v_63, __v_19, __v_51, __v_60, __v_62, __v_69, __v_71, __v_57, __v_59, __v_76, __v_77, __v_78, __v_12, __v_13, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __v_79: G = __r_arr[0]; + let __r_arr: [G; OUT_558] = { let __args: [G; IN_558] = [__v_8, __v_79, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[558].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_558] = unsafe { *(result.output.as_ptr() as *const [G; OUT_558]) }; __ret } else { aiur_fn_558(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_561] = []; + record.function_queries[561].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_30.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +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_562], ExecError> { + stacker::maybe_grow(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_563] = { let __args: [G; IN_563] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[563].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_563] = unsafe { *(result.output.as_ptr() as *const [G; OUT_563]) }; __ret } else { aiur_fn_563(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_562] = [__v_6]; + record.function_queries[562].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +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_563], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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; 6] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_563] = [__v_8]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + match __v_7.as_canonical_u64() { + 5u64 => { + let __v_18: G = G::from_u64(0); + let __r_arr: [G; OUT_522] = { let __args: [G; IN_522] = [__v_1, __v_8, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[522].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_522] = unsafe { *(result.output.as_ptr() as *const [G; OUT_522]) }; __ret } else { aiur_fn_522(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(1); + let __v_23: G = G::from_u64(1); + let __v_24: G = { let __values: [G; 3] = [__v_22, __v_23, __v_23]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_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 !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_25: G = __r_arr[0]; + let __v_26: G = { let __values: [G; 6] = [__v_20, __v_4, __v_21, __v_24, __v_19, __v_25]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_563] = [__v_26]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(1); + let __v_22: G = { let __values: [G; 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 __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_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 !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_26: G = __r_arr[0]; + let __v_27: G = { let __values: [G; 6] = [__v_18, __v_4, __v_19, __v_22, __v_25, __v_26]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_563] = [__v_27]; + record.function_queries[563].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_564: usize = 1; +const IN_564: usize = 1; +const OUT_564: usize = 1; +fn aiur_fn_564( + inp: [G; IN_564], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_564], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 6] = [__v_6, __v_7, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_564] = [__v_8]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __r_arr: [G; OUT_564] = { let __args: [G; IN_564] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[564].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_564] = unsafe { *(result.output.as_ptr() as *const [G; OUT_564]) }; __ret } else { aiur_fn_564(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 6] = [__v_6, __v_2, __v_7, __v_3, __v_4, __v_8]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_564] = [__v_9]; + record.function_queries[564].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_565: usize = 1; +const IN_565: usize = 1; +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_565], 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 }; + 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; 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_565] = [__v_9]; + record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_565] = { let __args: [G; IN_565] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[565].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_565] = unsafe { *(result.output.as_ptr() as *const [G; OUT_565]) }; __ret } else { aiur_fn_565(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_2, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_565] = [__v_9]; + record.function_queries[565].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_566: usize = 2; +const IN_566: usize = 2; +const OUT_566: usize = 4; +fn aiur_fn_566( + inp: [G; IN_566], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_566], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 3] = [__v_10, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_566] = [__v_8, __v_9, __v_12, __v_15]; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_566] = [__v_3, __v_4, __v_5, __v_6]; + record.function_queries[566].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_566] = { let __args: [G; IN_566] = [__v_7, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[566].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_566] = unsafe { *(result.output.as_ptr() as *const [G; OUT_566]) }; __ret } else { aiur_fn_566(__args, record, io_buffer, __cu)? } }; + let __v_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_566] = [__v_10, __v_11, __v_12, __v_13]; + record.function_queries[566].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_567: usize = 6; +const IN_567: usize = 6; +const OUT_567: usize = 1; +fn aiur_fn_567( + inp: [G; IN_567], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_567], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_538] = { let __args: [G; IN_538] = [__v_0, __v_1, __v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[538].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_538] = unsafe { *(result.output.as_ptr() as *const [G; OUT_538]) }; __ret } else { aiur_fn_538(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_567] = [__v_7]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_514] = { let __args: [G; IN_514] = [__v_0, __v_5, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[514].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_514] = unsafe { *(result.output.as_ptr() as *const [G; OUT_514]) }; __ret } else { aiur_fn_514(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_567] = [__v_6]; + record.function_queries[567].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_568: usize = 2; +const IN_568: usize = 2; +const OUT_568: usize = 1; +fn aiur_fn_568( + inp: [G; IN_568], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_568], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_568] = [__v_10]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + match __v_9.as_canonical_u64() { + 5u64 => { + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = { let __values: [G; 3] = [__v_20, __v_12, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_568] = [__v_22]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_568] = { let __args: [G; IN_568] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[568].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_568] = unsafe { *(result.output.as_ptr() as *const [G; OUT_568]) }; __ret } else { aiur_fn_568(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __v_23: G = { let __values: [G; 3] = [__v_20, __v_21, __v_22]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_568] = [__v_23]; + record.function_queries[568].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_569: usize = 3; +const IN_569: usize = 3; +const OUT_569: usize = 1; +fn aiur_fn_569( + inp: [G; IN_569], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_569], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_1, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + match __v_36.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_569] = [__v_0]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_37: G = G::from_u64(0); + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_1, __v_2, __v_2, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + match __v_38.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_569] = [__v_39]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_569] = [__v_0]; + record.function_queries[569].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_36.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_570: usize = 4; +const IN_570: usize = 4; +const OUT_570: usize = 2; +fn aiur_fn_570( + inp: [G; IN_570], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_570], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_570] = [__v_7, __v_8]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + match __v_7.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_17, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + match __v_18.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(1); + let __v_20: G = (__v_3 + __v_19); + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = __r_arr[1]; + let __ret: [G; OUT_570] = [__v_21, __v_22]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_552] = { let __args: [G; IN_552] = [__v_14, __v_9, __v_10, __v_12, __v_13, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[552].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_552] = unsafe { *(result.output.as_ptr() as *const [G; OUT_552]) }; __ret } else { aiur_fn_552(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_21: G = __loaded[0]; + let __v_22: G = __loaded[1]; + let __v_23: G = __loaded[2]; + let __v_24: G = __loaded[3]; + let __v_25: G = __loaded[4]; + let __v_26: G = __loaded[5]; + let __v_27: G = __loaded[6]; + let __v_28: G = __loaded[7]; + let __v_29: G = __loaded[8]; + let __v_30: G = __loaded[9]; + let __v_31: G = __loaded[10]; + match __v_21.as_canonical_u64() { + 5u64 => { + match __v_30.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(1); + let __v_33: G = (__v_3 + __v_32); + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __ret: [G; OUT_570] = [__v_34, __v_35]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_32: G = G::from_u64(1); + let __ret: [G; OUT_570] = [__v_32, __v_19]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_32: G = G::from_u64(1); + let __v_33: G = (__v_3 + __v_32); + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __ret: [G; OUT_570] = [__v_34, __v_35]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_18.as_canonical_u64())); + }, + } + }, + _ => { + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_3 + __v_18); + let __r_arr: [G; OUT_570] = { let __args: [G; IN_570] = [__v_0, __v_6, __v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[570].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_570] = unsafe { *(result.output.as_ptr() as *const [G; OUT_570]) }; __ret } else { aiur_fn_570(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __v_21: G = __r_arr[1]; + let __ret: [G; OUT_570] = [__v_20, __v_21]; + record.function_queries[570].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_571: usize = 4; +const IN_571: usize = 4; +const OUT_571: usize = 1; +fn aiur_fn_571( + inp: [G; IN_571], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_571], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + 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_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_571] = [__v_3]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = (__v_5 - __v_1); + let __v_8: G = G::from_bool((__v_7 == G::ZERO)); + match __v_8.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_571] = [__v_3]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + 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]; + let __v_20: G = __loaded[10]; + match __v_10.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_21: G = __r_arr[0]; + let __v_22: G = (__v_3 + __v_21); + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_6, __v_1, __v_2, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_571] = [__v_23]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_571] = { let __args: [G; IN_571] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[571].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_571] = unsafe { *(result.output.as_ptr() as *const [G; OUT_571]) }; __ret } else { aiur_fn_571(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_571] = [__v_21]; + record.function_queries[571].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +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_572], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + match __v_3.as_canonical_u64() { + 5u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = { let __values: [G; 32] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_13, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + match __v_47.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(0); + let __ret: [G; OUT_572] = [__v_48]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_12.as_canonical_u64() { + 0u64 => { + let __v_48: G = G::from_u64(0); + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_13, __v_1, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __ret: [G; OUT_572] = [__v_49]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_48: G = G::from_u64(0); + let __ret: [G; OUT_572] = [__v_48]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_47.as_canonical_u64())); + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __ret: [G; OUT_572] = [__v_14]; + record.function_queries[572].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_573: usize = 3; +const IN_573: usize = 3; +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_573], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_573] = [__v_6]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + let __v_11: G = __loaded[5]; + let __v_12: G = __loaded[6]; + let __v_13: G = __loaded[7]; + let __v_14: G = __loaded[8]; + let __v_15: G = __loaded[9]; + let __v_16: G = __loaded[10]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_16, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = (__v_17 * __v_15); + match __v_18.as_canonical_u64() { + 0u64 => { + let __v_19: G = G::from_u64(1); + let __v_20: G = (__v_2 + __v_19); + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_0, __v_5, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_573] = [__v_21]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_19: G = G::from_u64(1); + let __ret: [G; OUT_573] = [__v_19]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_17: G = G::from_u64(1); + let __v_18: G = (__v_2 + __v_17); + let __r_arr: [G; OUT_573] = { let __args: [G; IN_573] = [__v_0, __v_5, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[573].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_573] = unsafe { *(result.output.as_ptr() as *const [G; OUT_573]) }; __ret } else { aiur_fn_573(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_573] = [__v_19]; + record.function_queries[573].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_574: usize = 3; +const IN_574: usize = 3; +const OUT_574: usize = 1; +fn aiur_fn_574( + inp: [G; IN_574], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_574], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + 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]; + let __v_10: G = __loaded[6]; + let __v_11: G = __loaded[7]; + let __v_12: G = __loaded[8]; + let __v_13: G = __loaded[9]; + let __v_14: G = __loaded[10]; + match __v_4.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_9, __v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_574] = [__v_15]; + record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_15: G = G::from_u64(1); + let __v_16: G = G::from_u64(1); + let __v_17: G = { let __values: [G; 5] = [__v_15, __v_16, __v_16, __v_16, __v_16]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_574] = [__v_17]; + record.function_queries[574].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_575: usize = 4; +const IN_575: usize = 4; +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_575], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __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_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 5] = [__v_7, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_575] = [__v_9]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __v_14: G = __loaded[6]; + let __v_15: G = __loaded[7]; + let __v_16: G = __loaded[8]; + let __v_17: G = __loaded[9]; + let __v_18: G = __loaded[10]; + match __v_8.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_494] = { let __args: [G; IN_494] = [__v_10, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[494].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_494] = unsafe { *(result.output.as_ptr() as *const [G; OUT_494]) }; __ret } else { aiur_fn_494(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_19, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_575] = [__v_22]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_575] = { let __args: [G; IN_575] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[575].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_575] = unsafe { *(result.output.as_ptr() as *const [G; OUT_575]) }; __ret } else { aiur_fn_575(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __ret: [G; OUT_575] = [__v_19]; + record.function_queries[575].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_576: usize = 3; +const IN_576: usize = 3; +const OUT_576: usize = 1; +fn aiur_fn_576( + inp: [G; IN_576], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_576], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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() { + 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 !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 = __r_arr[0]; + let __r_arr: [G; OUT_576] = { let __args: [G; IN_576] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[576].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_576] = unsafe { *(result.output.as_ptr() as *const [G; OUT_576]) }; __ret } else { aiur_fn_576(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_576] = [__v_9]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 5] = [__v_7, __v_8, __v_8, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_576] = [__v_9]; + record.function_queries[576].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_577: usize = 3; +const IN_577: usize = 3; +const OUT_577: usize = 1; +fn aiur_fn_577( + inp: [G; IN_577], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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 __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_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + match __v_7.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_498] = { let __args: [G; IN_498] = [__v_1, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[498].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_498] = unsafe { *(result.output.as_ptr() as *const [G; OUT_498]) }; __ret } else { aiur_fn_498(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __v_13: G = G::from_u64(1); + let __v_14: G = { let __values: [G; 5] = [__v_12, __v_13, __v_13, __v_13, __v_13]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_577] = [__v_14]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + match __v_13.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_24: G = __r_arr[0]; + let __v_25: G = { let __a_val = __v_24.as_canonical_u64(); let __b_val = __v_16.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::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_25.as_canonical_u64() { + 1u64 => { + let __v_26: G = G::from_u64(1); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 5] = [__v_26, __v_27, __v_27, __v_27, __v_27]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_577] = [__v_28]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_6, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_502] = { let __args: [G; IN_502] = [__v_26, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[502].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_502] = unsafe { *(result.output.as_ptr() as *const [G; OUT_502]) }; __ret } else { aiur_fn_502(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_28: G = G::from_u64(1); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 5] = [__v_28, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_577] = [__v_30]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = G::from_u64(1); + let __v_31: G = { let __values: [G; 5] = [__v_29, __v_30, __v_30, __v_30, __v_30]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_32: G = { let __values: [G; 5] = [__v_28, __v_8, __v_26, __v_9, __v_31]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_577] = [__v_32]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_27.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_25.as_canonical_u64())); + }, + } + }, + _ => { + let __v_24: G = G::from_u64(1); + let __v_25: G = G::from_u64(1); + let __v_26: G = { let __values: [G; 5] = [__v_24, __v_25, __v_25, __v_25, __v_25]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_577] = [__v_26]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + let __v_11: G = G::from_u64(1); + let __v_12: G = G::from_u64(1); + let __v_13: G = { let __values: [G; 5] = [__v_11, __v_12, __v_12, __v_12, __v_12]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_577] = [__v_13]; + record.function_queries[577].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_578: usize = 3; +const IN_578: usize = 3; +const OUT_578: usize = 1; +fn aiur_fn_578( + inp: [G; IN_578], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_578], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_578] = [__v_4]; + record.function_queries[578].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_579: usize = 4; +const IN_579: usize = 4; +const OUT_579: usize = 1; +fn aiur_fn_579( + inp: [G; IN_579], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_579], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_579] = [__v_0]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = G::from_u64(0); + let __r_arr: [G; OUT_396] = { let __args: [G; IN_396] = [__v_6, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[396].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_396] = unsafe { *(result.output.as_ptr() as *const [G; OUT_396]) }; __ret } else { aiur_fn_396(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = G::from_u64(1); + let __v_12: G = (__v_1 - __v_11); + let __v_13: G = G::from_u64(1); + let __v_14: G = (__v_3 + __v_13); + let __r_arr: [G; OUT_579] = { let __args: [G; IN_579] = [__v_10, __v_12, __v_2, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[579].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_579] = unsafe { *(result.output.as_ptr() as *const [G; OUT_579]) }; __ret } else { aiur_fn_579(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __ret: [G; OUT_579] = [__v_15]; + record.function_queries[579].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_580: usize = 2; +const IN_580: usize = 2; +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_580], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_0, __v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_0, __v_2, __v_3, __v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_580] = []; + record.function_queries[580].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_581: usize = 2; +const IN_581: usize = 2; +const OUT_581: usize = 2; +fn aiur_fn_581( + inp: [G; IN_581], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_581], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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(0); + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_581] = [__v_5, __v_8]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __ret: [G; OUT_581] = [__v_6, __v_7]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + match __v_7.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_540] = { let __args: [G; IN_540] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[540].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_540] = unsafe { *(result.output.as_ptr() as *const [G; OUT_540]) }; __ret } else { aiur_fn_540(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __ret: [G; OUT_581] = [__v_10, __v_18]; + record.function_queries[581].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_581] = { let __args: [G; IN_581] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[581].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_581] = unsafe { *(result.output.as_ptr() as *const [G; OUT_581]) }; __ret } else { aiur_fn_581(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __ret: [G; OUT_581] = [__v_18, __v_19]; + record.function_queries[581].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_582: usize = 3; +const IN_582: usize = 3; +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_582], ExecError> { + stacker::maybe_grow(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; 5] = [__v_6, __v_7, __v_7, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_582] = [__v_8]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_4, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_582] = [__v_7]; + record.function_queries[582].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_574] = { let __args: [G; IN_574] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[574].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_574] = unsafe { *(result.output.as_ptr() as *const [G; OUT_574]) }; __ret } else { aiur_fn_574(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_582] = { let __args: [G; IN_582] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[582].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_582] = unsafe { *(result.output.as_ptr() as *const [G; OUT_582]) }; __ret } else { aiur_fn_582(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_582] = [__v_9]; + record.function_queries[582].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_583: usize = 5; +const IN_583: usize = 5; +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_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]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_583] = []; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_572] = { let __args: [G; IN_572] = [__v_6, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[572].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_572] = unsafe { *(result.output.as_ptr() as *const [G; OUT_572]) }; __ret } else { aiur_fn_572(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_583] = []; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + 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]; + let __v_20: G = __loaded[10]; + match __v_10.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_12, __v_15, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + if (__v_21 != __v_22) { + return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_22.as_canonical_u64() }); + } + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_583] = []; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_583] = { let __args: [G; IN_583] = [__v_7, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[583].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_583] = unsafe { *(result.output.as_ptr() as *const [G; OUT_583]) }; __ret } else { aiur_fn_583(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_583] = []; + record.function_queries[583].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_584: usize = 6; +const IN_584: usize = 6; +const OUT_584: usize = 1; +fn aiur_fn_584( + inp: [G; IN_584], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_584], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __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_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_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 __v_11: G = G::from_u64(0); + let __ret: [G; OUT_584] = [__v_11]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_12: G = __loaded[0]; + 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]; + match __v_12.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_14, __v_15, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_23, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_24, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + match __v_25.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 !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_26: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_27: G = __r_arr[0]; + let __v_28: G = (__v_26 - __v_27); + match __v_28.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_1, __v_17, __v_15, __v_8, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + match __v_29.as_canonical_u64() { + 1u64 => { + let __v_30: G = G::from_u64(1); + let __ret: [G; OUT_584] = [__v_30]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_584] = [__v_30]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __ret: [G; OUT_584] = [__v_29]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __ret: [G; OUT_584] = [__v_26]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __r_arr: [G; OUT_584] = { let __args: [G; IN_584] = [__v_0, __v_1, __v_10, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[584].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_584] = unsafe { *(result.output.as_ptr() as *const [G; OUT_584]) }; __ret } else { aiur_fn_584(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_584] = [__v_23]; + record.function_queries[584].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_585: usize = 6; +const IN_585: usize = 6; +const OUT_585: usize = 1; +fn aiur_fn_585( + inp: [G; IN_585], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_585], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = 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_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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() { + 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_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + 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_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_585] = [__v_12]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_5, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_24.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_25: G = __loaded[0]; + let __v_26: G = __loaded[1]; + let __v_27: G = __loaded[2]; + let __v_28: G = __loaded[3]; + let __v_29: G = __loaded[4]; + let __v_30: G = __loaded[5]; + let __v_31: G = __loaded[6]; + let __v_32: G = __loaded[7]; + let __v_33: G = __loaded[8]; + let __v_34: G = __loaded[9]; + let __v_35: G = __loaded[10]; + match __v_13.as_canonical_u64() { + 6u64 => { + match __v_25.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_578] = { let __args: [G; IN_578] = [__v_27, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[578].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_578] = unsafe { *(result.output.as_ptr() as *const [G; OUT_578]) }; __ret } else { aiur_fn_578(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_36, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_37, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + match __v_38.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_585] = { let __args: [G; IN_585] = [__v_8, __v_11, __v_2, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[585].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_585] = unsafe { *(result.output.as_ptr() as *const [G; OUT_585]) }; __ret } else { aiur_fn_585(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __ret: [G; OUT_585] = [__v_39]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_39: G = G::from_u64(0); + let __ret: [G; OUT_585] = [__v_39]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_36: G = G::from_u64(0); + let __ret: [G; OUT_585] = [__v_36]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_36: G = G::from_u64(0); + let __ret: [G; OUT_585] = [__v_36]; + record.function_queries[585].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_586: usize = 20; +const IN_586: usize = 20; +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_586], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(1); + let __v_25: G = { let __values: [G; 5] = [__v_23, __v_24, __v_24, __v_24, __v_24]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_586] = [__v_25]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_17, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_23.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_24: G = __loaded[0]; + let __v_25: G = __loaded[1]; + let __v_26: G = __loaded[2]; + let __v_27: G = __loaded[3]; + let __v_28: G = __loaded[4]; + let __v_29: G = __loaded[5]; + let __v_30: G = __loaded[6]; + let __v_31: G = __loaded[7]; + let __v_32: G = __loaded[8]; + let __v_33: G = __loaded[9]; + let __v_34: G = __loaded[10]; + match __v_24.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_548] = { let __args: [G; IN_548] = [__v_0, __v_27, __v_21, __v_26, __v_19, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[548].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_548] = unsafe { *(result.output.as_ptr() as *const [G; OUT_548]) }; __ret } else { aiur_fn_548(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(1); + let __v_38: G = (__v_19 + __v_37); + let __r_arr: [G; OUT_586] = { let __args: [G; IN_586] = [__v_0, __v_1, __v_22, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[586].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_586] = unsafe { *(result.output.as_ptr() as *const [G; OUT_586]) }; __ret } else { aiur_fn_586(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = { let __values: [G; 5] = [__v_36, __v_21, __v_30, __v_35, __v_39]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_586] = [__v_40]; + record.function_queries[586].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_24.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_587: usize = 11; +const IN_587: usize = 11; +const OUT_587: usize = 1; +fn aiur_fn_587( + inp: [G; IN_587], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_587], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + match __v_11.as_canonical_u64() { + 1u64 => { + let __v_14: G = G::from_u64(1); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 3] = [__v_14, __v_15, __v_15]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_587] = [__v_16]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = (__v_5 + __v_10); + let __v_17: G = (__v_6 + __v_16); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = (__v_5 - __v_12); + let __v_20: G = (__v_19 + __v_10); + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_394] = { let __args: [G; IN_394] = [__v_18, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[394].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_394] = unsafe { *(result.output.as_ptr() as *const [G; OUT_394]) }; __ret } else { aiur_fn_394(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_22, __v_7, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_535] = { let __args: [G; IN_535] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[535].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_535] = unsafe { *(result.output.as_ptr() as *const [G; OUT_535]) }; __ret } else { aiur_fn_535(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_716] = { let __args: [G; IN_716] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[716].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_716] = unsafe { *(result.output.as_ptr() as *const [G; OUT_716]) }; __ret } else { aiur_fn_716(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_26, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_415] = { let __args: [G; IN_415] = [__v_25, __v_27, __v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[415].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_415] = unsafe { *(result.output.as_ptr() as *const [G; OUT_415]) }; __ret } else { aiur_fn_415(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_29: G = __r_arr[0]; + let __v_30: G = (__v_17 + __v_29); + let __v_31: G = G::from_u64(1); + let __v_32: G = (__v_30 - __v_31); + let __v_33: G = (__v_4 + __v_14); + let __v_34: G = (__v_32 - __v_33); + let __v_35: G = G::from_u64(1); + let __v_36: G = (__v_30 - __v_35); + let __v_37: G = (__v_6 + __v_12); + let __v_38: G = (__v_36 - __v_37); + let __r_arr: [G; OUT_200] = { let __args: [G; IN_200] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[200].get_mut(&__args[..]) { 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_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_40, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 4] = [__v_42, __v_34, __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 __r_arr: [G; OUT_401] = { let __args: [G; IN_401] = [__v_44, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[401].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_401] = unsafe { *(result.output.as_ptr() as *const [G; OUT_401]) }; __ret } else { aiur_fn_401(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = { let __values: [G; 4] = [__v_46, __v_38, __v_47, __v_47]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_49: G = G::from_u64(0); + let __r_arr: [G; OUT_524] = { let __args: [G; IN_524] = [__v_48, __v_29, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[524].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_524] = unsafe { *(result.output.as_ptr() as *const [G; OUT_524]) }; __ret } else { aiur_fn_524(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __v_51: G = G::from_u64(3); + let __v_52: G = G::from_u64(0); + let __v_53: G = { let __values: [G; 4] = [__v_51, __v_45, __v_50, __v_52]; let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_525] = { let __args: [G; IN_525] = [__v_53, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[525].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_525] = unsafe { *(result.output.as_ptr() as *const [G; OUT_525]) }; __ret } else { aiur_fn_525(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __v_55: G = G::from_u64(0); + let __v_56: G = G::from_u64(1); + let __v_57: G = (__v_10 + __v_56); + let __r_arr: [G; OUT_587] = { let __args: [G; IN_587] = [__v_13, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_57]; let __cu = unconstrained; if let Some(result) = record.function_queries[587].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_587] = unsafe { *(result.output.as_ptr() as *const [G; OUT_587]) }; __ret } else { aiur_fn_587(__args, record, io_buffer, __cu)? } }; + let __v_58: G = __r_arr[0]; + let __v_59: G = { let __values: [G; 3] = [__v_55, __v_54, __v_58]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_587] = [__v_59]; + record.function_queries[587].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_588: usize = 7; +const IN_588: usize = 7; +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_588], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = { let __values: [G; 32] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_4, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + match __v_40.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_588] = []; + record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_41: G = G::from_u64(0); + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_5, __v_6, __v_41]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_588] = []; + record.function_queries[588].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_40.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_589: usize = 9; +const IN_589: usize = 9; +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_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 __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 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_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_589] = []; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_10.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_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]; + match __v_12.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_22, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __v_24: G = (__v_8 - __v_0); + let __v_25: G = G::from_bool((__v_24 == G::ZERO)); + let __v_26: G = G::from_u64(1); + let __v_27: G = (__v_26 - __v_25); + let __v_28: G = (__v_23 * __v_27); + match __v_28.as_canonical_u64() { + 1u64 => { + if (__v_15 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_2.as_canonical_u64() }); + } + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_1, __v_14, __v_2, __v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __v_29: G = (__v_2 + __v_3); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_1, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __v_32: G = __r_arr[2]; + let __v_33: G = (__v_15 + __v_16); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_30, __v_31, __v_32, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { 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_37: G = __r_arr[0]; + let __v_38: G = G::from_u64(1); + if (__v_37 != __v_38) { + return Err(ExecError::AssertEqMismatch { lhs: __v_37.as_canonical_u64(), rhs: __v_38.as_canonical_u64() }); + } + let __v_39: G = G::from_u64(1); + let __v_40: G = (__v_8 + __v_39); + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_589] = []; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_29: G = G::from_u64(1); + let __v_30: G = (__v_8 + __v_29); + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_589] = []; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_28.as_canonical_u64())); + }, + } + }, + _ => { + let __v_23: G = G::from_u64(1); + let __v_24: G = (__v_8 + __v_23); + let __r_arr: [G; OUT_589] = { let __args: [G; IN_589] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_11, __v_6, __v_7, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[589].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_589] = unsafe { *(result.output.as_ptr() as *const [G; OUT_589]) }; __ret } else { aiur_fn_589(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_589] = []; + record.function_queries[589].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_590: usize = 5; +const IN_590: usize = 5; +const OUT_590: usize = 0; +fn aiur_fn_590( + inp: [G; IN_590], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_590], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + 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_591] = { let __args: [G; IN_591] = [__v_0, __v_1, __v_2, __v_7, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_590] = []; + record.function_queries[590].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_591: usize = 6; +const IN_591: usize = 6; +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_591], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_591] = []; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + let __v_13: G = __loaded[3]; + match __v_10.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_454] = { let __args: [G; IN_454] = [__v_7, __v_11, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[454].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_454] = unsafe { *(result.output.as_ptr() as *const [G; OUT_454]) }; __ret } else { aiur_fn_454(__args, record, io_buffer, __cu)? } }; + let __v_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() }); + } + let __v_16: G = G::from_u64(0); + let __v_17: G = { let __values: [G; 3] = [__v_16, __v_7, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_2 - __v_18); + let __r_arr: [G; OUT_591] = { let __args: [G; IN_591] = [__v_8, __v_12, __v_19, __v_17, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[591].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_591] = unsafe { *(result.output.as_ptr() as *const [G; OUT_591]) }; __ret } else { aiur_fn_591(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_591] = []; + record.function_queries[591].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_592: usize = 2; +const IN_592: usize = 2; +const OUT_592: usize = 1; +fn aiur_fn_592( + inp: [G; IN_592], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_592], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = (__v_0 - __v_1); + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_592] = [__v_3]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_3: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_592] = [__v_4]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_4: G = G::from_u64(2); + let __ret: [G; OUT_592] = [__v_4]; + record.function_queries[592].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + } + }) +} + +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_593], 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_593] = [__v_1]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_593] = [__v_0]; + record.function_queries[593].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_594: usize = 0; +const IN_594: usize = 0; +const OUT_594: usize = 2; +fn aiur_fn_594( + inp: [G; IN_594], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_594], 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_594] = [__v_0, __v_1]; + record.function_queries[594].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_595: usize = 0; +const IN_595: usize = 0; +const OUT_595: usize = 2; +fn aiur_fn_595( + inp: [G; IN_595], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_595], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(0); + let __v_1: G = G::from_u64(0); + let __ret: [G; OUT_595] = [__v_0, __v_1]; + record.function_queries[595].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_596: usize = 0; +const IN_596: usize = 0; +const OUT_596: usize = 2; +fn aiur_fn_596( + inp: [G; IN_596], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_596], 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_596] = [__v_0, __v_1]; + record.function_queries[596].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_597: usize = 0; +const IN_597: usize = 0; +const OUT_597: usize = 2; +fn aiur_fn_597( + inp: [G; IN_597], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_597], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(1); + let __v_1: G = G::from_u64(0); + let __ret: [G; OUT_597] = [__v_0, __v_1]; + record.function_queries[597].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_598: usize = 0; +const IN_598: usize = 0; +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_598], 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_598] = [__v_0, __v_1]; + record.function_queries[598].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_599: usize = 4; +const IN_599: usize = 4; +const OUT_599: usize = 2; +fn aiur_fn_599( + inp: [G; IN_599], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_599], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __v_4: G = (__v_1 * __v_3); + let __ret: [G; OUT_599] = [__v_2, __v_4]; + record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_599] = [__v_0, __v_1]; + record.function_queries[599].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_600: usize = 1; +const IN_600: usize = 1; +const OUT_600: usize = 2; +fn aiur_fn_600( + inp: [G; IN_600], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_600], 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_600] = [__v_0, __v_1]; + record.function_queries[600].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_601: usize = 3; +const IN_601: usize = 3; +const OUT_601: usize = 1; +fn aiur_fn_601( + inp: [G; IN_601], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_601] = [__v_6]; + record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = (__v_4 - __v_0); + match __v_6.as_canonical_u64() { + 0u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_7 + __v_2); + let __ret: [G; OUT_601] = [__v_8]; + record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_2 + __v_7); + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_601] = [__v_9]; + record.function_queries[601].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +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_602], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_0, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_601] = { let __args: [G; IN_601] = [__v_1, __v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[601].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_601] = unsafe { *(result.output.as_ptr() as *const [G; OUT_601]) }; __ret } else { aiur_fn_601(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_4.as_canonical_u64() { + 0u64 => { + match __v_6.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __ret: [G; OUT_602] = [__v_8, __v_9]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __ret: [G; OUT_602] = [__v_7, __v_8]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + match __v_6.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = __r_arr[1]; + let __ret: [G; OUT_602] = [__v_7, __v_8]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_602] = [__v_7, __v_8]; + record.function_queries[602].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_603: usize = 6; +const IN_603: usize = 6; +const OUT_603: usize = 1; +fn aiur_fn_603( + inp: [G; IN_603], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_603], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_603] = [__v_6]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(0); + let __ret: [G; OUT_603] = [__v_6]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_9: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_9]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_603] = [__v_9]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_12: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_12: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + 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_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_603] = [__v_20]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_12: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_12: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_12: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + 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_15: G = __loaded[0]; + let __v_16: G = __loaded[1]; + let __v_17: G = __loaded[2]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_6, __v_7, __v_8, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_10, __v_11, __v_15, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_18, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_603] = [__v_20]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_603] = [__v_12]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }, + 4u64 => { + match __v_3.as_canonical_u64() { + 4u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_603] = [__v_6]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(2); + let __ret: [G; OUT_603] = [__v_6]; + record.function_queries[603].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_604: usize = 2; +const IN_604: usize = 2; +const OUT_604: usize = 1; +fn aiur_fn_604( + inp: [G; IN_604], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_604], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_604] = [__v_8]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_604] = [__v_8]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(2); + let __ret: [G; OUT_604] = [__v_11]; + record.function_queries[604].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_9.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_5, __v_6, __v_7, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __ret: [G; OUT_604] = [__v_16]; + record.function_queries[604].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_605: usize = 2; +const IN_605: usize = 2; +const OUT_605: usize = 2; +fn aiur_fn_605( + inp: [G; IN_605], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_605], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __ret: [G; OUT_605] = [__v_3, __v_4]; + record.function_queries[605].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_606: usize = 2; +const IN_606: usize = 2; +const OUT_606: usize = 1; +fn aiur_fn_606( + inp: [G; IN_606], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_606], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = (__v_0 - __v_1); + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_606] = [__v_3]; + record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __r_arr: [G; OUT_607] = { let __args: [G; IN_607] = [__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[607].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_607] = unsafe { *(result.output.as_ptr() as *const [G; OUT_607]) }; __ret } else { aiur_fn_607(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_606] = [__v_11]; + record.function_queries[606].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_607: usize = 8; +const IN_607: usize = 8; +const OUT_607: usize = 1; +fn aiur_fn_607( + inp: [G; IN_607], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_607], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_11]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_11: G = __loaded[0]; + let __v_12: G = __loaded[1]; + let __v_13: G = __loaded[2]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_14]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_11]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_604] = { let __args: [G; IN_604] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[604].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_604] = unsafe { *(result.output.as_ptr() as *const [G; OUT_604]) }; __ret } else { aiur_fn_604(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_10]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_10]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_10]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 5u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_10]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 6u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_12]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 7u64 => { + match __v_4.as_canonical_u64() { + 8u64 => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 8u64 => { + match __v_4.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __ret: [G; OUT_607] = [__v_12]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(2); + let __ret: [G; OUT_607] = [__v_8]; + record.function_queries[607].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_608: usize = 3; +const IN_608: usize = 3; +const OUT_608: usize = 2; +fn aiur_fn_608( + inp: [G; IN_608], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_608], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = (__v_0 - __v_1); + match __v_3.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __ret: [G; OUT_608] = [__v_4, __v_5]; + record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __r_arr: [G; OUT_609] = { let __args: [G; IN_609] = [__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[609].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_609] = unsafe { *(result.output.as_ptr() as *const [G; OUT_609]) }; __ret } else { aiur_fn_609(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __ret: [G; OUT_608] = [__v_12, __v_13]; + record.function_queries[608].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_609: usize = 9; +const IN_609: usize = 9; +const OUT_609: usize = 2; +fn aiur_fn_609( + inp: [G; IN_609], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_609], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_10, __v_11]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_12, __v_13]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_12: G = __loaded[0]; + let __v_13: G = __loaded[1]; + let __v_14: G = __loaded[2]; + let __r_arr: [G; OUT_603] = { let __args: [G; IN_603] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[603].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_603] = unsafe { *(result.output.as_ptr() as *const [G; OUT_603]) }; __ret } else { aiur_fn_603(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_16, __v_17]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_12, __v_13]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_605] = { let __args: [G; IN_605] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[605].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_605] = unsafe { *(result.output.as_ptr() as *const [G; OUT_605]) }; __ret } else { aiur_fn_605(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_13, __v_14]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 3u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_13, __v_14]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 4u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_13, __v_14]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 5u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_13, __v_14]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 6u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_6, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_17, __v_18]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 7u64 => { + match __v_4.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_610] = { let __args: [G; IN_610] = [__v_1, __v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[610].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_610] = unsafe { *(result.output.as_ptr() as *const [G; OUT_610]) }; __ret } else { aiur_fn_610(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __v_11: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_10, __v_11]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 8u64 => { + match __v_4.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_602] = { let __args: [G; IN_602] = [__v_1, __v_5, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[602].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_602] = unsafe { *(result.output.as_ptr() as *const [G; OUT_602]) }; __ret } else { aiur_fn_602(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_12, __v_13, __v_14, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_9, __v_10, __v_16, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_18, __v_19]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = __r_arr[1]; + let __ret: [G; OUT_609] = [__v_9, __v_10]; + record.function_queries[609].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_610: usize = 4; +const IN_610: usize = 4; +const OUT_610: usize = 1; +fn aiur_fn_610( + inp: [G; IN_610], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_610], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_611] = { let __args: [G; IN_611] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[611].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_611] = unsafe { *(result.output.as_ptr() as *const [G; OUT_611]) }; __ret } else { aiur_fn_611(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_610] = [__v_4]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_610] = [__v_4]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + 1u64 => { + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(2); + let __ret: [G; OUT_610] = [__v_4]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + 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 !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_4: G = __r_arr[0]; + let __ret: [G; OUT_610] = [__v_4]; + record.function_queries[610].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_611: usize = 2; +const IN_611: usize = 2; +const OUT_611: usize = 1; +fn aiur_fn_611( + inp: [G; IN_611], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_611], 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_312] = { let __args: [G; IN_312] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_312] = { let __args: [G; IN_312] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[312].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_312] = unsafe { *(result.output.as_ptr() as *const [G; OUT_312]) }; __ret } else { aiur_fn_312(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + match __v_6.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_611] = [__v_7]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_611] = [__v_6]; + record.function_queries[611].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_612: usize = 2; +const IN_612: usize = 2; +const OUT_612: usize = 1; +fn aiur_fn_612( + inp: [G; IN_612], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_612], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __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 __v_12: G = G::from_u64(1); + let __ret: [G; OUT_612] = [__v_12]; + record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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]; + 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]; + match __v_12.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_612] = { let __args: [G; IN_612] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[612].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_612] = unsafe { *(result.output.as_ptr() as *const [G; OUT_612]) }; __ret } else { aiur_fn_612(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_613] = { let __args: [G; IN_613] = [__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[613].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_613] = unsafe { *(result.output.as_ptr() as *const [G; OUT_613]) }; __ret } else { aiur_fn_613(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __ret: [G; OUT_612] = [__v_24]; + record.function_queries[612].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_613: usize = 16; +const IN_613: usize = 16; +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_613], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_7, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_2, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_21, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_20, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_19, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_18, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_17, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_16, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_613] = [__v_30]; + record.function_queries[613].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +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_614], 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].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 __v_8: G = G::from_u64(2); + let __ret: [G; OUT_614] = [__v_8]; + record.function_queries[614].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_614] = { let __args: [G; IN_614] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[614].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_614] = unsafe { *(result.output.as_ptr() as *const [G; OUT_614]) }; __ret } else { aiur_fn_614(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_8, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_614] = [__v_10]; + record.function_queries[614].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_615: usize = 6; +const IN_615: usize = 6; +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_615], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + match __v_0.as_canonical_u64() { + _ => { + match __v_3.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_6, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_615] = [__v_10]; + record.function_queries[615].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __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 __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_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]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(1); + let __ret: [G; OUT_616] = [__v_12]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __ret: [G; OUT_616] = [__v_12]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_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]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(2); + let __ret: [G; OUT_616] = [__v_12]; + record.function_queries[616].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_615] = { let __args: [G; IN_615] = [__v_3, __v_4, __v_5, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[615].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_615] = unsafe { *(result.output.as_ptr() as *const [G; OUT_615]) }; __ret } else { aiur_fn_615(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_6, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __ret: [G; OUT_616] = [__v_14]; + record.function_queries[616].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())); + }, + } + }) +} + +const INPUT_SIZE_617: usize = 7; +const IN_617: usize = 7; +const OUT_617: usize = 2; +fn aiur_fn_617( + inp: [G; IN_617], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_617], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + match __v_0.as_canonical_u64() { + _ => { + match __v_3.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_11, __v_12, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_8, __v_9, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __ret: [G; OUT_617] = [__v_17, __v_18]; + record.function_queries[617].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_618: usize = 3; +const IN_618: usize = 3; +const OUT_618: usize = 2; +fn aiur_fn_618( + inp: [G; IN_618], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_618], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __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_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_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]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_596] = { let __args: [G; IN_596] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[596].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_596] = unsafe { *(result.output.as_ptr() as *const [G; OUT_596]) }; __ret } else { aiur_fn_596(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_618] = [__v_13, __v_14]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_594] = { let __args: [G; IN_594] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[594].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_594] = unsafe { *(result.output.as_ptr() as *const [G; OUT_594]) }; __ret } else { aiur_fn_594(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_618] = [__v_13, __v_14]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 0u64 => { + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_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]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_598] = { let __args: [G; IN_598] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[598].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_598] = unsafe { *(result.output.as_ptr() as *const [G; OUT_598]) }; __ret } else { aiur_fn_598(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __ret: [G; OUT_618] = [__v_13, __v_14]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_617] = { let __args: [G; IN_617] = [__v_4, __v_5, __v_6, __v_9, __v_10, __v_11, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[617].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_617] = unsafe { *(result.output.as_ptr() as *const [G; OUT_617]) }; __ret } else { aiur_fn_617(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = __r_arr[1]; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_7, __v_12, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __v_15: G = __r_arr[0]; + let __v_16: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __v_18: G = __r_arr[1]; + let __ret: [G; OUT_618] = [__v_17, __v_18]; + record.function_queries[618].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_619: usize = 11; +const IN_619: usize = 11; +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_619], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_11: G = G::from_u64(2); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __v_11: G = G::from_u64(3); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_11: G = G::from_u64(4); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_11: G = G::from_u64(5); + let __ret: [G; OUT_619] = [__v_11]; + record.function_queries[619].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_620: usize = 22; +const IN_620: usize = 22; +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_620], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + match __v_24.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_621] = { let __args: [G; IN_621] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[621].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_621] = unsafe { *(result.output.as_ptr() as *const [G; OUT_621]) }; __ret } else { aiur_fn_621(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __ret: [G; OUT_620] = [__v_25]; + record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_620] = [__v_24]; + record.function_queries[620].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_621: usize = 22; +const IN_621: usize = 22; +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_621], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + match __v_0.as_canonical_u64() { + 1u64 => { + match __v_11.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_26]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 2u64 => { + match __v_11.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_26]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 3u64 => { + match __v_11.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_28]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 4u64 => { + match __v_11.as_canonical_u64() { + 4u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_24]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 0u64 => { + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_26]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 5u64 => { + match __v_11.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_27: G = __r_arr[0]; + 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 !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_28: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_27, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_26, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_25, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_36]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 6u64 => { + match __v_11.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_25, __v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_30]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 7u64 => { + match __v_11.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __r_arr: [G; OUT_606] = { let __args: [G; IN_606] = [__v_2, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[606].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_606] = unsafe { *(result.output.as_ptr() as *const [G; OUT_606]) }; __ret } else { aiur_fn_606(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_616] = { let __args: [G; IN_616] = [__v_7, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[616].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_616] = unsafe { *(result.output.as_ptr() as *const [G; OUT_616]) }; __ret } else { aiur_fn_616(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_27, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_26, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_25, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_24, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_23, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __r_arr: [G; OUT_593] = { let __args: [G; IN_593] = [__v_22, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[593].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_593] = unsafe { *(result.output.as_ptr() as *const [G; OUT_593]) }; __ret } else { aiur_fn_593(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __ret: [G; OUT_621] = [__v_36]; + record.function_queries[621].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_622: usize = 23; +const IN_622: usize = 23; +const OUT_622: usize = 2; +fn aiur_fn_622( + inp: [G; IN_622], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_622], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + match __v_25.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_623] = { let __args: [G; IN_623] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[623].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_623] = unsafe { *(result.output.as_ptr() as *const [G; OUT_623]) }; __ret } else { aiur_fn_623(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __ret: [G; OUT_622] = [__v_26, __v_27]; + record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_25]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __ret: [G; OUT_622] = [__v_26, __v_27]; + record.function_queries[622].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_623: usize = 23; +const IN_623: usize = 23; +const OUT_623: usize = 2; +fn aiur_fn_623( + inp: [G; IN_623], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_623], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + match __v_0.as_canonical_u64() { + 1u64 => { + match __v_11.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_14, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_32, __v_33]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 2u64 => { + match __v_11.as_canonical_u64() { + 2u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_14, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_28, __v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_30, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_32, __v_33]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 3u64 => { + match __v_11.as_canonical_u64() { + 3u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_3, __v_14, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_28, __v_29, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_37, __v_38]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 4u64 => { + match __v_11.as_canonical_u64() { + 4u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_26, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_28, __v_29]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 0u64 => { + match __v_11.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __v_27: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_28]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __v_30: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_26, __v_27, __v_29, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_31, __v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_33, __v_34]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 5u64 => { + match __v_11.as_canonical_u64() { + 5u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __v_37: G = __r_arr[1]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_38, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_40: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_36, __v_37, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_33, __v_34, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_30, __v_31, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __v_52: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_27, __v_28, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_55, __v_56]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 6u64 => { + match __v_11.as_canonical_u64() { + 6u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_30, __v_31, __v_37, __v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_27, __v_28, __v_39, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_41, __v_42]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_43, __v_44]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + 7u64 => { + match __v_11.as_canonical_u64() { + 7u64 => { + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_1, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __v_25: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_3, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_26: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_26]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_27: G = __r_arr[0]; + let __v_28: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_4, __v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_29: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_29]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_30: G = __r_arr[0]; + let __v_31: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_5, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_6, __v_17]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __v_37: G = __r_arr[1]; + let __r_arr: [G; OUT_592] = { let __args: [G; IN_592] = [__v_8, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[592].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_592] = unsafe { *(result.output.as_ptr() as *const [G; OUT_592]) }; __ret } else { aiur_fn_592(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __r_arr: [G; OUT_600] = { let __args: [G; IN_600] = [__v_38]; let __cu = unconstrained; if let Some(result) = record.function_queries[600].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_600] = unsafe { *(result.output.as_ptr() as *const [G; OUT_600]) }; __ret } else { aiur_fn_600(__args, record, io_buffer, __cu)? } }; + let __v_39: G = __r_arr[0]; + let __v_40: G = __r_arr[1]; + let __r_arr: [G; OUT_608] = { let __args: [G; IN_608] = [__v_2, __v_13, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[608].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_608] = unsafe { *(result.output.as_ptr() as *const [G; OUT_608]) }; __ret } else { aiur_fn_608(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __r_arr: [G; OUT_618] = { let __args: [G; IN_618] = [__v_7, __v_18, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[618].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_618] = unsafe { *(result.output.as_ptr() as *const [G; OUT_618]) }; __ret } else { aiur_fn_618(__args, record, io_buffer, __cu)? } }; + let __v_43: G = __r_arr[0]; + let __v_44: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_41, __v_42, __v_43, __v_44]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_39, __v_40, __v_45, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_36, __v_37, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_33, __v_34, __v_49, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __v_52: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_30, __v_31, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_53: G = __r_arr[0]; + let __v_54: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_27, __v_28, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + let __r_arr: [G; OUT_599] = { let __args: [G; IN_599] = [__v_24, __v_25, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[599].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_599] = unsafe { *(result.output.as_ptr() as *const [G; OUT_599]) }; __ret } else { aiur_fn_599(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = __r_arr[1]; + let __ret: [G; OUT_623] = [__v_57, __v_58]; + record.function_queries[623].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_11.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_624: usize = 4; +const IN_624: usize = 4; +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_624], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(1); + let __v_8: G = G::from_u64(1); + let __v_9: G = { let __values: [G; 3] = [__v_7, __v_8, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_624] = [__v_9]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __v_19: G = G::from_u64(1); + let __v_20: G = (__v_3 + __v_19); + let __r_arr: [G; OUT_624] = { let __args: [G; IN_624] = [__v_0, __v_6, __v_2, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[624].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_624] = unsafe { *(result.output.as_ptr() as *const [G; OUT_624]) }; __ret } else { aiur_fn_624(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_18, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + match __v_22.as_canonical_u64() { + 1u64 => { + let __v_23: G = G::from_u64(0); + let __v_24: G = { let __values: [G; 3] = [__v_23, __v_3, __v_21]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_624] = [__v_24]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __ret: [G; OUT_624] = [__v_21]; + record.function_queries[624].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_22.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_625: usize = 1; +const IN_625: usize = 1; +const OUT_625: usize = 0; +fn aiur_fn_625( + inp: [G; IN_625], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_625], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(0); + let __v_2: G = G::from_u64(0); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = { let __values: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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 __v_37: G = G::from_u64(0); + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_0, __v_33, __v_36, __v_37, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_625] = []; + record.function_queries[625].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_626: usize = 12; +const IN_626: usize = 12; +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_626], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + match __v_0.as_canonical_u64() { + 5u64 => { + let __ret: [G; OUT_626] = [__v_10]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + match __v_13.as_canonical_u64() { + 5u64 => { + let __ret: [G; OUT_626] = [__v_23]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __v_46: G = G::from_u64(0); + let __v_47: G = G::from_u64(0); + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __v_56: G = { let __values: [G; 32] = [__v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_626] = [__v_56]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 7u64 => { + let __ret: [G; OUT_626] = [__v_10]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = { let __values: [G; 32] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_626] = [__v_44]; + record.function_queries[626].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_627: usize = 5; +const IN_627: usize = 5; +const OUT_627: usize = 0; +fn aiur_fn_627( + inp: [G; IN_627], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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 __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_1, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_627] = []; + record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __v_14: G = __loaded[6]; + let __v_15: G = __loaded[7]; + let __v_16: G = __loaded[8]; + let __v_17: G = __loaded[9]; + let __v_18: G = __loaded[10]; + let __r_arr: [G; OUT_626] = { let __args: [G; IN_626] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[626].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_626] = unsafe { *(result.output.as_ptr() as *const [G; OUT_626]) }; __ret } else { aiur_fn_626(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_19, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + let __v_23: G = (__v_3 + __v_22); + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_19, __v_21, __v_23, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_627] = []; + record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_629] = { let __args: [G; IN_629] = [__v_1, __v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[629].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_629] = unsafe { *(result.output.as_ptr() as *const [G; OUT_629]) }; __ret } else { aiur_fn_629(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_628] = { let __args: [G; IN_628] = [__v_19, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[628].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_628] = unsafe { *(result.output.as_ptr() as *const [G; OUT_628]) }; __ret } else { aiur_fn_628(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __v_22: G = G::from_u64(1); + let __v_23: G = (__v_3 + __v_22); + let __r_arr: [G; OUT_627] = { let __args: [G; IN_627] = [__v_7, __v_19, __v_21, __v_23, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[627].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_627] = unsafe { *(result.output.as_ptr() as *const [G; OUT_627]) }; __ret } else { aiur_fn_627(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_627] = []; + record.function_queries[627].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +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_628], ExecError> { + 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 __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = { let __values: [G; 32] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + match __v_35.as_canonical_u64() { + 1u64 => { + 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_628] = [__v_38]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(1); + let __v_38: G = G::from_u64(1); + let __v_39: G = { let __values: [G; 3] = [__v_37, __v_38, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_40: G = { let __values: [G; 3] = [__v_36, __v_1, __v_39]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_628] = [__v_40]; + record.function_queries[628].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_35.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_629: usize = 3; +const IN_629: usize = 3; +const OUT_629: usize = 0; +fn aiur_fn_629( + inp: [G; IN_629], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_629], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + match __v_36.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_629] = []; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + 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 !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_37: G = __r_arr[0]; + match __v_37.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_629] = []; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __ret: [G; OUT_629] = []; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_630] = { let __args: [G; IN_630] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[630].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_630] = unsafe { *(result.output.as_ptr() as *const [G; OUT_630]) }; __ret } else { aiur_fn_630(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_629] = []; + record.function_queries[629].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_36.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_630: usize = 2; +const IN_630: usize = 2; +const OUT_630: usize = 0; +fn aiur_fn_630( + inp: [G; IN_630], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_630], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !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_3: G = __r_arr[0]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_630] = []; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __ret: [G; OUT_630] = []; + record.function_queries[630].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_634] = { let __args: [G; IN_634] = [__v_2, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[634].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_634] = unsafe { *(result.output.as_ptr() as *const [G; OUT_634]) }; __ret } else { aiur_fn_634(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_236] = unsafe { *(result.output.as_ptr() as *const [G; OUT_236]) }; __ret } else { aiur_fn_236(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + if (__v_5 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); + } + let __v_9: G = G::from_u64(1); + if (__v_7 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); + } + let __ret: [G; OUT_630] = []; + record.function_queries[630].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_631] = [__v_7]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + let __v_11: G = __loaded[5]; + let __v_12: G = __loaded[6]; + let __v_13: G = __loaded[7]; + let __v_14: G = __loaded[8]; + let __v_15: G = __loaded[9]; + let __v_16: G = __loaded[10]; + let __r_arr: [G; OUT_631] = { let __args: [G; IN_631] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[631].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_631] = unsafe { *(result.output.as_ptr() as *const [G; OUT_631]) }; __ret } else { aiur_fn_631(__args, record, io_buffer, __cu)? } }; + let __v_17: G = __r_arr[0]; + let __r_arr: [G; OUT_619] = { let __args: [G; IN_619] = [__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[619].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_619] = unsafe { *(result.output.as_ptr() as *const [G; OUT_619]) }; __ret } else { aiur_fn_619(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + match __v_18.as_canonical_u64() { + 1u64 => { + let __v_19: G = G::from_u64(0); + let __v_20: G = { let __values: [G; 3] = [__v_19, __v_3, __v_17]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_631] = [__v_20]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_631] = [__v_17]; + record.function_queries[631].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_632: usize = 1; +const IN_632: usize = 1; +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_632], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(1); + let __ret: [G; OUT_632] = [__v_4]; + record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { if !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_4: G = __r_arr[0]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_632] = { let __args: [G; IN_632] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[632].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_632] = unsafe { *(result.output.as_ptr() as *const [G; OUT_632]) }; __ret } else { aiur_fn_632(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_632] = [__v_5]; + record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_632] = [__v_5]; + record.function_queries[632].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_633: usize = 1; +const IN_633: usize = 1; +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_633], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __v_6: G = { let __values: [G; 3] = [__v_4, __v_5, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_633] = [__v_6]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_2, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_633] = [__v_5]; + record.function_queries[633].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_634: usize = 2; +const IN_634: usize = 2; +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_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 = G::from_u64(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 = { let __values: [G; 3] = [__v_2, __v_0, __v_5]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_7: G = G::from_u64(32); + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_6, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_634] = [__v_8]; + record.function_queries[634].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_635: usize = 3; +const IN_635: usize = 3; +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_635], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_635] = [__v_0]; + record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_633] = { let __args: [G; IN_633] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[633].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_633] = unsafe { *(result.output.as_ptr() as *const [G; OUT_633]) }; __ret } else { aiur_fn_633(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_0, __v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_635] = [__v_0]; + record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_2 - __v_6); + let __r_arr: [G; OUT_635] = { let __args: [G; IN_635] = [__v_4, __v_1, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[635].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_635] = unsafe { *(result.output.as_ptr() as *const [G; OUT_635]) }; __ret } else { aiur_fn_635(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_635] = [__v_8]; + record.function_queries[635].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_636: usize = 3; +const IN_636: usize = 3; +const OUT_636: usize = 1; +fn aiur_fn_636( + inp: [G; IN_636], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_636], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_636] = [__v_8]; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_637] = { let __args: [G; IN_637] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[637].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_637] = unsafe { *(result.output.as_ptr() as *const [G; OUT_637]) }; __ret } else { aiur_fn_637(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_636] = { let __args: [G; IN_636] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[636].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_636] = unsafe { *(result.output.as_ptr() as *const [G; OUT_636]) }; __ret } else { aiur_fn_636(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_6, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_636] = [__v_8]; + record.function_queries[636].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +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_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_198] = { let __args: [G; IN_198] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_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_637] = [__v_6]; + record.function_queries[637].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 __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_637] = [__v_8]; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_0, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_640] = { let __args: [G; IN_640] = [__v_4, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[640].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_640] = unsafe { *(result.output.as_ptr() as *const [G; OUT_640]) }; __ret } else { aiur_fn_640(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __ret: [G; OUT_637] = [__v_5]; + record.function_queries[637].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_638: usize = 3; +const IN_638: usize = 3; +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_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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_638] = [__v_8]; + record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_638] = { let __args: [G; IN_638] = [__v_5, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[638].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_638] = unsafe { *(result.output.as_ptr() as *const [G; OUT_638]) }; __ret } else { aiur_fn_638(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_4, __v_6, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_638] = [__v_7]; + record.function_queries[638].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +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_639], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + match __v_4.as_canonical_u64() { + 1u64 => { + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(1); + let __v_9: G = G::from_u64(1); + let __v_10: G = { let __values: [G; 3] = [__v_8, __v_9, __v_9]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_11: G = { let __values: [G; 3] = [__v_7, __v_0, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_639] = [__v_11]; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __v_14: G = __loaded[6]; + let __v_15: G = __loaded[7]; + let __v_16: G = __loaded[8]; + let __v_17: G = __loaded[9]; + let __v_18: G = __loaded[10]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + let __v_26: G = __loaded[6]; + let __v_27: G = __loaded[7]; + let __v_28: G = __loaded[8]; + let __v_29: G = __loaded[9]; + let __v_30: G = __loaded[10]; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __v_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_639] = [__v_34]; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_33: G = G::from_u64(0); + let __r_arr: [G; OUT_639] = { let __args: [G; IN_639] = [__v_0, __v_6, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[639].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_639] = unsafe { *(result.output.as_ptr() as *const [G; OUT_639]) }; __ret } else { aiur_fn_639(__args, record, io_buffer, __cu)? } }; + let __v_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_639] = [__v_35]; + record.function_queries[639].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_640: usize = 3; +const IN_640: usize = 3; +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_640], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_640] = [__v_8]; + record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(1); + let __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_641] = { let __args: [G; IN_641] = [__v_5, __v_1, __v_2, __v_4, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __ret: [G; OUT_640] = [__v_11]; + record.function_queries[640].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_641: usize = 5; +const IN_641: usize = 5; +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_641], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(1); + let __v_11: G = { let __values: [G; 3] = [__v_9, __v_10, __v_10]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_12: G = { let __values: [G; 3] = [__v_8, __v_4, __v_11]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_641] = [__v_12]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_20.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_21: G = __loaded[0]; + let __v_22: G = __loaded[1]; + let __v_23: G = __loaded[2]; + let __v_24: G = __loaded[3]; + let __v_25: G = __loaded[4]; + let __v_26: G = __loaded[5]; + let __v_27: G = __loaded[6]; + let __v_28: G = __loaded[7]; + let __v_29: G = __loaded[8]; + let __v_30: G = __loaded[9]; + let __v_31: G = __loaded[10]; + let __r_arr: [G; OUT_622] = { let __args: [G; IN_622] = [__v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[622].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_622] = unsafe { *(result.output.as_ptr() as *const [G; OUT_622]) }; __ret } else { aiur_fn_622(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + match __v_32.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_7, __v_1, __v_2, __v_6, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __ret: [G; OUT_641] = [__v_35]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(1); + let __v_37: G = G::from_u64(1); + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_39: G = { let __values: [G; 3] = [__v_35, __v_6, __v_38]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_641] = { let __args: [G; IN_641] = [__v_7, __v_1, __v_2, __v_6, __v_39]; let __cu = unconstrained; if let Some(result) = record.function_queries[641].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_641] = unsafe { *(result.output.as_ptr() as *const [G; OUT_641]) }; __ret } else { aiur_fn_641(__args, record, io_buffer, __cu)? } }; + let __v_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_641] = [__v_41]; + record.function_queries[641].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_642: usize = 2; +const IN_642: usize = 2; +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_642], 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 __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(1); + let __ret: [G; OUT_642] = [__v_8]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_642] = [__v_8]; + record.function_queries[642].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 __v_8: G = G::from_u64(0); + let __ret: [G; OUT_642] = [__v_8]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_236] = { let __args: [G; IN_236] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[236].get_mut(&__args[..]) { 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_8: G = __r_arr[0]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_9: G = G::from_u64(0); + let __ret: [G; OUT_642] = [__v_9]; + record.function_queries[642].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_642] = { let __args: [G; IN_642] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[642].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_642] = unsafe { *(result.output.as_ptr() as *const [G; OUT_642]) }; __ret } else { aiur_fn_642(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __ret: [G; OUT_642] = [__v_9]; + record.function_queries[642].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_643: usize = 11; +const IN_643: usize = 11; +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_643], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_643] = [__v_3]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_11: G = G::from_u64(1); + let __ret: [G; OUT_643] = [__v_11]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_643] = [__v_11]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + 2u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_643] = [__v_11]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __ret: [G; OUT_643] = [__v_4]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_643] = [__v_11]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __ret: [G; OUT_643] = [__v_8]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __ret: [G; OUT_643] = [__v_7]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_643] = [__v_9]; + record.function_queries[643].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_644: usize = 2; +const IN_644: usize = 2; +const OUT_644: usize = 1; +fn aiur_fn_644( + inp: [G; IN_644], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_644], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_644] = [__v_6]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_644] = [__v_6]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + let __v_18: G = G::from_u64(1); + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__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[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __v_20: G = (__v_18 - __v_19); + let __ret: [G; OUT_644] = [__v_20]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = (__v_6 * __v_7); + let __ret: [G; OUT_644] = [__v_8]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = (__v_6 * __v_7); + let __ret: [G; OUT_644] = [__v_8]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = (__v_6 * __v_7); + let __ret: [G; OUT_644] = [__v_8]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_3, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = (__v_7 * __v_8); + let __v_10: G = (__v_6 * __v_9); + let __ret: [G; OUT_644] = [__v_10]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_644] = [__v_6]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_644] = [__v_6]; + record.function_queries[644].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_645: usize = 3; +const IN_645: usize = 3; +const OUT_645: usize = 0; +fn aiur_fn_645( + inp: [G; IN_645], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_645], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_645] = []; + record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_644] = { let __args: [G; IN_644] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[644].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_644] = unsafe { *(result.output.as_ptr() as *const [G; OUT_644]) }; __ret } else { aiur_fn_644(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(1); + if (__v_3 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + let __ret: [G; OUT_645] = []; + record.function_queries[645].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_646: usize = 4; +const IN_646: usize = 4; +const OUT_646: usize = 0; +fn aiur_fn_646( + inp: [G; IN_646], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_646], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_646] = []; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_646] = []; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __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_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_646] = []; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_4: G = __loaded[0]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __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_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_4, __v_5, __v_6, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_7, __v_8, __v_9, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_646] = []; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __v_4: G = { let __a_val = __v_1.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_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() }); + } + let __ret: [G; OUT_646] = []; + record.function_queries[646].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_647: usize = 2; +const IN_647: usize = 2; +const OUT_647: usize = 0; +fn aiur_fn_647( + inp: [G; IN_647], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_647], 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_647] = []; + record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_3.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_5, __v_6, __v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_647] = []; + record.function_queries[647].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_648: usize = 4; +const IN_648: usize = 4; +const OUT_648: usize = 0; +fn aiur_fn_648( + inp: [G; IN_648], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_648], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 0u64 => { + let __v_8: G = { let __a_val = __v_5.as_canonical_u64(); let __b_val = __v_1.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + let __v_9: G = G::from_u64(1); + if (__v_8 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); + } + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __r_arr: [G; OUT_646] = { let __args: [G; IN_646] = [__v_8, __v_9, __v_10, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[646].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_646] = unsafe { *(result.output.as_ptr() as *const [G; OUT_646]) }; __ret } else { aiur_fn_646(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_3, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_8.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__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[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_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() }); + } + let __r_arr: [G; OUT_647] = { let __args: [G; IN_647] = [__v_6, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[647].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_647] = unsafe { *(result.output.as_ptr() as *const [G; OUT_647]) }; __ret } else { aiur_fn_647(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_1 + __v_8); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_1 + __v_8); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_5, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_1 + __v_8); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_9, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_7, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_648] = []; + record.function_queries[648].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_649: usize = 12; +const IN_649: usize = 12; +const OUT_649: usize = 0; +fn aiur_fn_649( + inp: [G; IN_649], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_649], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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 __r_arr: [G; OUT_444] = { let __args: [G; IN_444] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[444].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_444] = unsafe { *(result.output.as_ptr() as *const [G; OUT_444]) }; __ret } else { aiur_fn_444(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __r_arr: [G; OUT_443] = { let __args: [G; IN_443] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[443].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_443] = unsafe { *(result.output.as_ptr() as *const [G; OUT_443]) }; __ret } else { aiur_fn_443(__args, record, io_buffer, __cu)? } }; + let __v_13: G = __r_arr[0]; + let __v_14: G = G::from_u64(0); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_13, __v_14, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + match __v_0.as_canonical_u64() { + 1u64 => { + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_649] = []; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_649] = []; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __v_15: G = G::from_u64(0); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_3, __v_15, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_649] = []; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_7, __v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_649] = []; + record.function_queries[649].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __ret: [G; OUT_649] = []; + record.function_queries[649].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 = 0; +fn aiur_fn_650( + inp: [G; IN_650], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_650], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __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_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + match __v_3.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_650] = []; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + match __v_4.as_canonical_u64() { + _ => { + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_648] = { let __args: [G; IN_648] = [__v_6, __v_8, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[648].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_648] = unsafe { *(result.output.as_ptr() as *const [G; OUT_648]) }; __ret } else { aiur_fn_648(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_650] = { let __args: [G; IN_650] = [__v_7, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[650].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_650] = unsafe { *(result.output.as_ptr() as *const [G; OUT_650]) }; __ret } else { aiur_fn_650(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_650] = []; + record.function_queries[650].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_651: usize = 2; +const IN_651: usize = 2; +const OUT_651: usize = 0; +fn aiur_fn_651( + inp: [G; IN_651], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_651], 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_249] = { let __args: [G; IN_249] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[249].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_249] = unsafe { *(result.output.as_ptr() as *const [G; OUT_249]) }; __ret } else { aiur_fn_249(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_2, __v_1, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_6: G = __loaded[0]; + let __v_7: G = __loaded[1]; + let __v_8: G = __loaded[2]; + let __v_9: G = __loaded[3]; + let __v_10: G = __loaded[4]; + let __v_11: G = __loaded[5]; + let __v_12: G = __loaded[6]; + let __v_13: G = __loaded[7]; + let __v_14: G = __loaded[8]; + let __v_15: G = __loaded[9]; + let __v_16: G = __loaded[10]; + match __v_6.as_canonical_u64() { + 5u64 => { + let __v_17: G = G::from_u64(1); + if (__v_7 != __v_17) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_17.as_canonical_u64() }); + } + let __v_18: G = G::from_u64(2); + if (__v_9 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); + } + let __r_arr: [G; OUT_198] = { let __args: [G; IN_198] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[198].get_mut(&__args[..]) { 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_19: G = __r_arr[0]; + 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() }); + } + let __v_21: G = G::from_u64(0); + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_11, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_1, __v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __r_arr: [G; OUT_250] = { let __args: [G; IN_250] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[250].get_mut(&__args[..]) { 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_24: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_23, __v_24]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + let __v_26: G = G::from_u64(1); + if (__v_25 != __v_26) { + return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_26.as_canonical_u64() }); + } + let __ret: [G; OUT_651] = []; + record.function_queries[651].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_6.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_652: usize = 14; +const IN_652: usize = 14; +const OUT_652: usize = 0; +fn aiur_fn_652( + inp: [G; IN_652], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_652], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __r_arr: [G; OUT_649] = { let __args: [G; IN_649] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[649].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_649] = unsafe { *(result.output.as_ptr() as *const [G; OUT_649]) }; __ret } else { aiur_fn_649(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_643] = { let __args: [G; IN_643] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[643].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_643] = unsafe { *(result.output.as_ptr() as *const [G; OUT_643]) }; __ret } else { aiur_fn_643(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + match __v_0.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 __r_arr: [G; OUT_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + 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_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __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_439] = { let __args: [G; IN_439] = [__v_3, __v_2, __v_21, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + 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_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: 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_18.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_19: G = __loaded[0]; + let __v_20: G = __loaded[1]; + let __v_21: G = __loaded[2]; + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_23]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { 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_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() }); + } + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __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 __r_arr: [G; OUT_439] = { let __args: [G; IN_439] = [__v_3, __v_2, __v_28, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + 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_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_3, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + match __v_4.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + 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_439] = { let __args: [G; IN_439] = [__v_3, __v_2, __v_21, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[439].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_439] = unsafe { *(result.output.as_ptr() as *const [G; OUT_439]) }; __ret } else { aiur_fn_439(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }, + 4u64 => { + 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_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_13, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_653] = { let __args: [G; IN_653] = [__v_19, __v_3, __v_1, __v_2, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[653].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_653] = unsafe { *(result.output.as_ptr() as *const [G; OUT_653]) }; __ret } else { aiur_fn_653(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + 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_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_588] = { let __args: [G; IN_588] = [__v_11, __v_2, __v_3, __v_4, __v_10, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[588].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_588] = unsafe { *(result.output.as_ptr() as *const [G; OUT_588]) }; __ret } else { aiur_fn_588(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_530] = { let __args: [G; IN_530] = [__v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[530].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_530] = unsafe { *(result.output.as_ptr() as *const [G; OUT_530]) }; __ret } else { aiur_fn_530(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __r_arr: [G; OUT_580] = { let __args: [G; IN_580] = [__v_19, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[580].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_580] = unsafe { *(result.output.as_ptr() as *const [G; OUT_580]) }; __ret } else { aiur_fn_580(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_499] = { let __args: [G; IN_499] = [__v_5, __v_3, __v_19, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[499].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_499] = unsafe { *(result.output.as_ptr() as *const [G; OUT_499]) }; __ret } else { aiur_fn_499(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + if (__v_6 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); + } + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + 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_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_559] = { let __args: [G; IN_559] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[559].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_559] = unsafe { *(result.output.as_ptr() as *const [G; OUT_559]) }; __ret } else { aiur_fn_559(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_12, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_19: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_19.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + let __v_26: G = __loaded[6]; + let __v_27: G = __loaded[7]; + let __v_28: G = __loaded[8]; + let __v_29: G = __loaded[9]; + let __v_30: G = __loaded[10]; + match __v_20.as_canonical_u64() { + 5u64 => { + if (__v_5 != __v_23) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); + } + let __r_arr: [G; OUT_590] = { let __args: [G; IN_590] = [__v_22, __v_2, __v_23, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[590].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_590] = unsafe { *(result.output.as_ptr() as *const [G; OUT_590]) }; __ret } else { aiur_fn_590(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_485] = { let __args: [G; IN_485] = [__v_2, __v_5, __v_24, __v_6, __v_3, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[485].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_485] = unsafe { *(result.output.as_ptr() as *const [G; OUT_485]) }; __ret } else { aiur_fn_485(__args, record, io_buffer, __cu)? } }; + let __v_31: G = (__v_23 + __v_24); + let __r_arr: [G; OUT_489] = { let __args: [G; IN_489] = [__v_22, __v_31]; let __cu = unconstrained; if let Some(result) = record.function_queries[489].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_489] = unsafe { *(result.output.as_ptr() as *const [G; OUT_489]) }; __ret } else { aiur_fn_489(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + let __v_34: G = __r_arr[2]; + let __v_35: G = G::from_u64(1); + let __v_36: G = G::from_u64(1); + let __v_37: G = { let __values: [G; 3] = [__v_35, __v_36, __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 __r_arr: [G; OUT_490] = { let __args: [G; IN_490] = [__v_2, __v_5, __v_32, __v_33, __v_34, __v_37, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[490].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_490] = unsafe { *(result.output.as_ptr() as *const [G; OUT_490]) }; __ret } else { aiur_fn_490(__args, record, io_buffer, __cu)? } }; + let __v_38: G = G::from_u64(1); + let __v_39: G = G::from_u64(1); + let __v_40: G = { let __values: [G; 3] = [__v_38, __v_39, __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 __r_arr: [G; OUT_493] = { let __args: [G; IN_493] = [__v_2, __v_5, __v_3, __v_40, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[493].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_493] = unsafe { *(result.output.as_ptr() as *const [G; OUT_493]) }; __ret } else { aiur_fn_493(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_20.as_canonical_u64())); + }, + } + }, + 7u64 => { + 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_438] = { let __args: [G; IN_438] = [__v_2, __v_17, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[438].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_438] = unsafe { *(result.output.as_ptr() as *const [G; OUT_438]) }; __ret } else { aiur_fn_438(__args, record, io_buffer, __cu)? } }; + let __v_18: G = __r_arr[0]; + let __r_arr: [G; OUT_645] = { let __args: [G; IN_645] = [__v_14, __v_2, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[645].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_645] = unsafe { *(result.output.as_ptr() as *const [G; OUT_645]) }; __ret } else { aiur_fn_645(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_561] = { let __args: [G; IN_561] = [__v_11, __v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_12, __v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[561].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_561] = unsafe { *(result.output.as_ptr() as *const [G; OUT_561]) }; __ret } else { aiur_fn_561(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_652] = []; + record.function_queries[652].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_653: usize = 6; +const IN_653: usize = 6; +const OUT_653: usize = 0; +fn aiur_fn_653( + inp: [G; IN_653], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_653], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_238] = { let __args: [G; IN_238] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[238].get_mut(&__args[..]) { 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_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_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() }); + } + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(2); + break '__mc_0 [__v_9, __v_10]; + }, + 1u64 => { + let __r_arr: [G; OUT_239] = { let __args: [G; IN_239] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[239].get_mut(&__args[..]) { 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_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_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() }); + } + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(3); + break '__mc_0 [__v_9, __v_10]; + }, + 2u64 => { + let __r_arr: [G; OUT_240] = { let __args: [G; IN_240] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[240].get_mut(&__args[..]) { 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_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_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() }); + } + let __r_arr: [G; OUT_651] = { let __args: [G; IN_651] = [__v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[651].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_651] = unsafe { *(result.output.as_ptr() as *const [G; OUT_651]) }; __ret } else { aiur_fn_651(__args, record, io_buffer, __cu)? } }; + let __v_9: G = G::from_u64(2); + let __v_10: G = G::from_u64(6); + break '__mc_0 [__v_9, __v_10]; + }, + 3u64 => { + let __r_arr: [G; OUT_241] = { let __args: [G; IN_241] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[241].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_241] = unsafe { *(result.output.as_ptr() as *const [G; OUT_241]) }; __ret } else { aiur_fn_241(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_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() }); + } + let __v_9: G = G::from_u64(1); + let __v_10: G = G::from_u64(5); + break '__mc_0 [__v_9, __v_10]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, +} + }; + let __v_6: G = __mc_out___mc_0[0]; + let __v_7: G = __mc_out___mc_0[1]; + if (__v_2 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_6.as_canonical_u64() }); + } + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_3, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = G::from_u64(1); + if (__v_9 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_10.as_canonical_u64() }); + } + let __ret: [G; OUT_653] = []; + record.function_queries[653].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_654], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = (__v_1 - __v_2); + match __v_3.as_canonical_u64() { + 0u64 => { + let __v_4: G = G::from_u64(1); + let __ret: [G; OUT_654] = [__v_4]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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]; + let __v_5: G = __loaded[1]; + let __v_6: G = __loaded[2]; + let __v_7: G = __loaded[3]; + match __v_4.as_canonical_u64() { + 5u64 => { + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_2 + __v_8); + let __r_arr: [G; OUT_654] = { let __args: [G; IN_654] = [__v_6, __v_1, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[654].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_654] = unsafe { *(result.output.as_ptr() as *const [G; OUT_654]) }; __ret } else { aiur_fn_654(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_654] = [__v_10]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_8: G = G::from_u64(0); + let __ret: [G; OUT_654] = [__v_8]; + record.function_queries[654].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_655: usize = 3; +const IN_655: usize = 3; +const OUT_655: usize = 0; +fn aiur_fn_655( + inp: [G; IN_655], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_655], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __v_3: G = G::from_u64(0); + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_0, __v_1, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_655] = []; + record.function_queries[655].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_656: usize = 4; +const IN_656: usize = 4; +const OUT_656: usize = 0; +fn aiur_fn_656( + inp: [G; IN_656], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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 = 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_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_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + let __v_10: G = __loaded[3]; + let __v_11: G = __loaded[4]; + let __v_12: G = __loaded[5]; + let __v_13: G = __loaded[6]; + let __v_14: G = __loaded[7]; + let __v_15: G = __loaded[8]; + let __v_16: G = __loaded[9]; + let __v_17: G = __loaded[10]; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_3, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __v_18: G = G::from_u64(1); + let __v_19: G = (__v_3 + __v_18); + let __r_arr: [G; OUT_656] = { let __args: [G; IN_656] = [__v_6, __v_1, __v_2, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[656].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_656] = unsafe { *(result.output.as_ptr() as *const [G; OUT_656]) }; __ret } else { aiur_fn_656(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_656] = []; + record.function_queries[656].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_4.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_657: usize = 1; +const IN_657: usize = 1; +const OUT_657: usize = 3; +fn aiur_fn_657( + inp: [G; IN_657], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_657], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_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_657] = [__v_3, __v_4, __v_2]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_657] = [__v_5, __v_3, __v_4]; + record.function_queries[657].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_658: usize = 2; +const IN_658: usize = 2; +const OUT_658: usize = 10; +fn aiur_fn_658( + inp: [G; IN_658], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_658] = [__v_2, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_3, __v_1]; + record.function_queries[658].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 !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_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_658] = [__v_11, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10]; + record.function_queries[658].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_659: usize = 2; +const IN_659: usize = 2; +const OUT_659: usize = 3; +fn aiur_fn_659( + inp: [G; IN_659], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_659] = [__v_2, __v_3, __v_1]; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + 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 !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_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_659] = [__v_4, __v_2, __v_3]; + record.function_queries[659].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_660: usize = 2; +const IN_660: usize = 2; +const OUT_660: usize = 3; +fn aiur_fn_660( + inp: [G; IN_660], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_660] = [__v_2, __v_3, __v_1]; + record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_660] = [__v_4, __v_2, __v_3]; + record.function_queries[660].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_661: usize = 2; +const IN_661: usize = 2; +const OUT_661: usize = 3; +fn aiur_fn_661( + inp: [G; IN_661], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_661] = [__v_2, __v_3, __v_1]; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_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_661] = [__v_4, __v_5, __v_3]; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(1); + let __ret: [G; OUT_661] = [__v_4, __v_5, __v_3]; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_4: G = G::from_u64(0); + let __v_5: G = G::from_u64(2); + let __ret: [G; OUT_661] = [__v_4, __v_5, __v_3]; + record.function_queries[661].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_662: usize = 2; +const IN_662: usize = 2; +const OUT_662: usize = 3; +fn aiur_fn_662( + inp: [G; IN_662], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_662] = [__v_2, __v_3, __v_1]; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_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_662] = [__v_4, __v_5, __v_3]; + record.function_queries[662].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_662] = [__v_4, __v_5, __v_3]; + record.function_queries[662].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_662] = [__v_4, __v_5, __v_3]; + record.function_queries[662].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_662] = [__v_4, __v_5, __v_3]; + record.function_queries[662].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_663: usize = 9; +const IN_663: usize = 9; +const OUT_663: usize = 2; +fn aiur_fn_663( + inp: [G; IN_663], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_663], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + 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_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __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_663] = [__v_12, __v_0]; + record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + 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 !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_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + 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_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__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[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __v_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_663] = [__v_39, __v_37]; + record.function_queries[663].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_664: usize = 2; +const IN_664: usize = 2; +const OUT_664: usize = 3; +fn aiur_fn_664( + inp: [G; IN_664], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_664] = [__v_2, __v_3, __v_1]; + record.function_queries[664].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 !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_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __r_arr: [G; OUT_663] = { let __args: [G; IN_663] = [__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[663].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_663] = unsafe { *(result.output.as_ptr() as *const [G; OUT_663]) }; __ret } else { aiur_fn_663(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_664] = [__v_13, __v_11, __v_12]; + record.function_queries[664].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_665: usize = 1; +const IN_665: usize = 1; +const OUT_665: usize = 41; +fn aiur_fn_665( + inp: [G; IN_665], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_665], 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 !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 __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 __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_1); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_1, record) }; + let __v_10: G = __b1_out[0]; + let __v_11: G = __b1_out[1]; + let __v_12: G = __b1_out[2]; + let __v_13: G = __b1_out[3]; + let __v_14: G = __b1_out[4]; + 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_660] = { let __args: [G; IN_660] = [__v_10, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __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_658] = { let __args: [G; IN_658] = [__v_11, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_27: G = __r_arr[6]; + 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_658] = { let __args: [G; IN_658] = [__v_12, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __v_34: G = __r_arr[3]; + let __v_35: G = __r_arr[4]; + let __v_36: G = __r_arr[5]; + let __v_37: G = __r_arr[6]; + let __v_38: G = __r_arr[7]; + let __v_39: G = __r_arr[8]; + let __v_40: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __v_42: G = __r_arr[1]; + let __v_43: G = __r_arr[2]; + let __v_44: G = __r_arr[3]; + let __v_45: G = __r_arr[4]; + let __v_46: G = __r_arr[5]; + let __v_47: G = __r_arr[6]; + let __v_48: G = __r_arr[7]; + let __v_49: G = __r_arr[8]; + let __v_50: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_50]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_51: G = __r_arr[0]; + let __v_52: G = __r_arr[1]; + let __v_53: G = __r_arr[2]; + let __v_54: G = __r_arr[3]; + let __v_55: G = __r_arr[4]; + let __v_56: G = __r_arr[5]; + let __v_57: G = __r_arr[6]; + let __v_58: G = __r_arr[7]; + let __v_59: G = __r_arr[8]; + let __v_60: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_15, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_61: G = __r_arr[0]; + let __v_62: G = __r_arr[1]; + let __v_63: G = __r_arr[2]; + let __ret: [G; OUT_665] = [__v_18, __v_19, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_61, __v_62, __v_63]; + record.function_queries[665].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_666: usize = 1; +const IN_666: usize = 1; +const OUT_666: usize = 49; +fn aiur_fn_666( + inp: [G; IN_666], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_666], 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 !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 __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 __r_arr: [G; OUT_665] = { let __args: [G; IN_665] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[665].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_665] = unsafe { *(result.output.as_ptr() as *const [G; OUT_665]) }; __ret } else { aiur_fn_665(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + let __v_42: G = __r_arr[32]; + let __v_43: G = __r_arr[33]; + let __v_44: G = __r_arr[34]; + let __v_45: G = __r_arr[35]; + let __v_46: G = __r_arr[36]; + let __v_47: G = __r_arr[37]; + 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_666] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50]; + record.function_queries[666].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_667: usize = 9; +const IN_667: usize = 9; +const OUT_667: usize = 2; +fn aiur_fn_667( + inp: [G; IN_667], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_667], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __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_667] = [__v_12, __v_0]; + record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_666] = { let __args: [G; IN_666] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[666].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_666] = unsafe { *(result.output.as_ptr() as *const [G; OUT_666]) }; __ret } else { aiur_fn_666(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + let __v_42: G = __r_arr[32]; + let __v_43: G = __r_arr[33]; + let __v_44: G = __r_arr[34]; + let __v_45: G = __r_arr[35]; + let __v_46: G = __r_arr[36]; + let __v_47: G = __r_arr[37]; + let __v_48: G = __r_arr[38]; + let __v_49: G = __r_arr[39]; + let __v_50: G = __r_arr[40]; + let __v_51: G = __r_arr[41]; + let __v_52: G = __r_arr[42]; + let __v_53: G = __r_arr[43]; + let __v_54: G = __r_arr[44]; + let __v_55: G = __r_arr[45]; + 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_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_59: G = __r_arr[0]; + let __v_60: G = __r_arr[1]; + let __v_61: G = __r_arr[2]; + let __v_62: G = __r_arr[3]; + let __v_63: G = __r_arr[4]; + 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_667] = { let __args: [G; IN_667] = [__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[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __v_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_667] = [__v_70, __v_68]; + record.function_queries[667].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_668: usize = 2; +const IN_668: usize = 2; +const OUT_668: usize = 3; +fn aiur_fn_668( + inp: [G; IN_668], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __ret: [G; OUT_668] = [__v_2, __v_3, __v_1]; + record.function_queries[668].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 !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_2: G = __r_arr[0]; + let __v_3: G = __r_arr[1]; + let __v_4: G = __r_arr[2]; + let __v_5: G = __r_arr[3]; + let __v_6: G = __r_arr[4]; + let __v_7: G = __r_arr[5]; + let __v_8: G = __r_arr[6]; + let __v_9: G = __r_arr[7]; + let __v_10: G = __r_arr[8]; + let __r_arr: [G; OUT_667] = { let __args: [G; IN_667] = [__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[667].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_667] = unsafe { *(result.output.as_ptr() as *const [G; OUT_667]) }; __ret } else { aiur_fn_667(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = G::from_u64(0); + let __ret: [G; OUT_668] = [__v_13, __v_11, __v_12]; + record.function_queries[668].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_669: usize = 1; +const IN_669: usize = 1; +const OUT_669: usize = 55; +fn aiur_fn_669( + inp: [G; IN_669], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_669], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record) }; + let __v_12: G = __b1_out[0]; + let __v_13: G = __b1_out[1]; + let __v_14: G = __b1_out[2]; + let __v_15: G = __b1_out[3]; + let __v_16: G = __b1_out[4]; + let __v_17: G = __b1_out[5]; + let __v_18: G = __b1_out[6]; + let __v_19: G = __b1_out[7]; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record) }; + let __v_20: G = __b1_out[0]; + let __v_21: G = __b1_out[1]; + let __v_22: G = __b1_out[2]; + let __v_23: G = __b1_out[3]; + let __v_24: G = __b1_out[4]; + let __v_25: G = __b1_out[5]; + let __v_26: G = __b1_out[6]; + let __v_27: G = __b1_out[7]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __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_661] = { let __args: [G; IN_661] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __v_37: G = __r_arr[3]; + let __v_38: G = __r_arr[4]; + let __v_39: G = __r_arr[5]; + let __v_40: G = __r_arr[6]; + let __v_41: G = __r_arr[7]; + let __v_42: G = __r_arr[8]; + let __v_43: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_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_669] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __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_660] = { let __args: [G; IN_660] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __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_658] = { let __args: [G; IN_658] = [__v_15, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __v_40: G = __r_arr[3]; + let __v_41: G = __r_arr[4]; + let __v_42: G = __r_arr[5]; + let __v_43: G = __r_arr[6]; + let __v_44: G = __r_arr[7]; + let __v_45: G = __r_arr[8]; + let __v_46: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_47: G = __r_arr[0]; + let __v_48: G = __r_arr[1]; + let __v_49: G = __r_arr[2]; + let __v_50: G = __r_arr[3]; + let __v_51: G = __r_arr[4]; + let __v_52: G = __r_arr[5]; + let __v_53: G = __r_arr[6]; + let __v_54: G = __r_arr[7]; + let __v_55: G = __r_arr[8]; + let __v_56: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_17, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = __r_arr[1]; + let __v_59: G = __r_arr[2]; + let __v_60: G = __r_arr[3]; + let __v_61: G = __r_arr[4]; + let __v_62: G = __r_arr[5]; + let __v_63: G = __r_arr[6]; + let __v_64: G = __r_arr[7]; + let __v_65: G = __r_arr[8]; + let __v_66: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_18, __v_66]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_67: G = __r_arr[0]; + let __v_68: G = __r_arr[1]; + let __v_69: G = __r_arr[2]; + let __v_70: G = __r_arr[3]; + let __v_71: G = __r_arr[4]; + let __v_72: G = __r_arr[5]; + let __v_73: G = __r_arr[6]; + let __v_74: G = __r_arr[7]; + let __v_75: G = __r_arr[8]; + let __v_76: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_19, __v_76]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_77: G = __r_arr[0]; + let __v_78: G = __r_arr[1]; + let __v_79: G = __r_arr[2]; + let __r_arr: [G; OUT_668] = { let __args: [G; IN_668] = [__v_20, __v_79]; let __cu = unconstrained; if let Some(result) = record.function_queries[668].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_668] = unsafe { *(result.output.as_ptr() as *const [G; OUT_668]) }; __ret } else { aiur_fn_668(__args, record, io_buffer, __cu)? } }; + let __v_80: G = __r_arr[0]; + let __v_81: G = __r_arr[1]; + let __v_82: G = __r_arr[2]; + let __v_83: G = G::from_u64(1); + let __v_84: G = G::from_u64(0); + let __ret: [G; OUT_669] = [__v_83, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_77, __v_78, __v_80, __v_81, __v_84, __v_84, __v_84, __v_84, __v_84, __v_84, __v_84, __v_82]; + record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __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_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __v_37: G = __r_arr[3]; + let __v_38: G = __r_arr[4]; + let __v_39: G = __r_arr[5]; + let __v_40: G = __r_arr[6]; + let __v_41: G = __r_arr[7]; + let __v_42: G = __r_arr[8]; + let __v_43: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __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 __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __v_55: G = __r_arr[1]; + let __v_56: G = __r_arr[2]; + let __v_57: G = __r_arr[3]; + let __v_58: G = __r_arr[4]; + let __v_59: G = __r_arr[5]; + let __v_60: G = __r_arr[6]; + 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_658] = { let __args: [G; IN_658] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = __r_arr[1]; + let __v_66: G = __r_arr[2]; + let __v_67: G = __r_arr[3]; + let __v_68: G = __r_arr[4]; + let __v_69: G = __r_arr[5]; + let __v_70: G = __r_arr[6]; + let __v_71: G = __r_arr[7]; + let __v_72: G = __r_arr[8]; + let __v_73: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __v_75: G = __r_arr[1]; + let __v_76: G = __r_arr[2]; + let __v_77: G = __r_arr[3]; + let __v_78: G = __r_arr[4]; + let __v_79: G = __r_arr[5]; + let __v_80: G = __r_arr[6]; + 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_659] = { let __args: [G; IN_659] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __v_85: G = __r_arr[1]; + let __v_86: G = __r_arr[2]; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __v_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_669] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + record.function_queries[669].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_670: usize = 1; +const IN_670: usize = 1; +const OUT_670: usize = 63; +fn aiur_fn_670( + inp: [G; IN_670], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_670], 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 !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 __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 __r_arr: [G; OUT_669] = { let __args: [G; IN_669] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[669].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_669] = unsafe { *(result.output.as_ptr() as *const [G; OUT_669]) }; __ret } else { aiur_fn_669(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + let __v_42: G = __r_arr[32]; + let __v_43: G = __r_arr[33]; + let __v_44: G = __r_arr[34]; + let __v_45: G = __r_arr[35]; + let __v_46: G = __r_arr[36]; + let __v_47: G = __r_arr[37]; + let __v_48: G = __r_arr[38]; + let __v_49: G = __r_arr[39]; + let __v_50: G = __r_arr[40]; + let __v_51: G = __r_arr[41]; + let __v_52: G = __r_arr[42]; + let __v_53: G = __r_arr[43]; + let __v_54: G = __r_arr[44]; + let __v_55: G = __r_arr[45]; + let __v_56: G = __r_arr[46]; + let __v_57: G = __r_arr[47]; + let __v_58: G = __r_arr[48]; + let __v_59: G = __r_arr[49]; + let __v_60: G = __r_arr[50]; + let __v_61: G = __r_arr[51]; + 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_670] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64]; + record.function_queries[670].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_671: usize = 9; +const IN_671: usize = 9; +const OUT_671: usize = 2; +fn aiur_fn_671( + inp: [G; IN_671], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_671], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __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_671] = [__v_12, __v_0]; + record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_670] = { let __args: [G; IN_670] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[670].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_670] = unsafe { *(result.output.as_ptr() as *const [G; OUT_670]) }; __ret } else { aiur_fn_670(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_14: G = __r_arr[4]; + let __v_15: G = __r_arr[5]; + let __v_16: G = __r_arr[6]; + let __v_17: G = __r_arr[7]; + let __v_18: G = __r_arr[8]; + let __v_19: G = __r_arr[9]; + let __v_20: G = __r_arr[10]; + let __v_21: G = __r_arr[11]; + let __v_22: G = __r_arr[12]; + let __v_23: G = __r_arr[13]; + let __v_24: G = __r_arr[14]; + let __v_25: G = __r_arr[15]; + let __v_26: G = __r_arr[16]; + let __v_27: G = __r_arr[17]; + let __v_28: G = __r_arr[18]; + let __v_29: G = __r_arr[19]; + let __v_30: G = __r_arr[20]; + let __v_31: G = __r_arr[21]; + let __v_32: G = __r_arr[22]; + let __v_33: G = __r_arr[23]; + let __v_34: G = __r_arr[24]; + let __v_35: G = __r_arr[25]; + let __v_36: G = __r_arr[26]; + let __v_37: G = __r_arr[27]; + let __v_38: G = __r_arr[28]; + let __v_39: G = __r_arr[29]; + let __v_40: G = __r_arr[30]; + let __v_41: G = __r_arr[31]; + let __v_42: G = __r_arr[32]; + let __v_43: G = __r_arr[33]; + let __v_44: G = __r_arr[34]; + let __v_45: G = __r_arr[35]; + let __v_46: G = __r_arr[36]; + let __v_47: G = __r_arr[37]; + let __v_48: G = __r_arr[38]; + let __v_49: G = __r_arr[39]; + let __v_50: G = __r_arr[40]; + let __v_51: G = __r_arr[41]; + let __v_52: G = __r_arr[42]; + let __v_53: G = __r_arr[43]; + let __v_54: G = __r_arr[44]; + let __v_55: G = __r_arr[45]; + let __v_56: G = __r_arr[46]; + let __v_57: G = __r_arr[47]; + let __v_58: G = __r_arr[48]; + let __v_59: G = __r_arr[49]; + let __v_60: G = __r_arr[50]; + let __v_61: G = __r_arr[51]; + let __v_62: G = __r_arr[52]; + let __v_63: G = __r_arr[53]; + let __v_64: G = __r_arr[54]; + let __v_65: G = __r_arr[55]; + let __v_66: G = __r_arr[56]; + let __v_67: G = __r_arr[57]; + let __v_68: G = __r_arr[58]; + let __v_69: G = __r_arr[59]; + 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_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_73: G = __r_arr[0]; + let __v_74: G = __r_arr[1]; + let __v_75: G = __r_arr[2]; + let __v_76: G = __r_arr[3]; + let __v_77: G = __r_arr[4]; + let __v_78: G = __r_arr[5]; + let __v_79: G = __r_arr[6]; + let __v_80: G = __r_arr[7]; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__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[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __v_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_671] = [__v_84, __v_82]; + record.function_queries[671].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_672: usize = 1; +const IN_672: usize = 1; +const OUT_672: usize = 55; +fn aiur_fn_672( + inp: [G; IN_672], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_672], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __v_5: G = __r_arr[2]; + let __v_6: G = __r_arr[3]; + let __v_7: G = __r_arr[4]; + let __v_8: G = __r_arr[5]; + let __v_9: G = __r_arr[6]; + let __v_10: G = __r_arr[7]; + let __v_11: G = __r_arr[8]; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_3); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_3, record) }; + let __v_12: G = __b1_out[0]; + let __v_13: G = __b1_out[1]; + let __v_14: G = __b1_out[2]; + let __v_15: G = __b1_out[3]; + let __v_16: G = __b1_out[4]; + let __v_17: G = __b1_out[5]; + let __v_18: G = __b1_out[6]; + let __v_19: G = __b1_out[7]; + let __b1_out: [G; 8] = if unconstrained { let __v: Vec = Bytes1::bit_decompose(&__v_4); let __a: [G; 8] = __v.try_into().unwrap(); __a } else { bytes1_bit_decompose_value(__v_4, record) }; + let __v_20: G = __b1_out[0]; + let __v_21: G = __b1_out[1]; + let __v_22: G = __b1_out[2]; + let __v_23: G = __b1_out[3]; + let __v_24: G = __b1_out[4]; + let __v_25: G = __b1_out[5]; + let __v_26: G = __b1_out[6]; + let __v_27: G = __b1_out[7]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_661] = { let __args: [G; IN_661] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __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_661] = { let __args: [G; IN_661] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[661].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_661] = unsafe { *(result.output.as_ptr() as *const [G; OUT_661]) }; __ret } else { aiur_fn_661(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __v_37: G = __r_arr[3]; + let __v_38: G = __r_arr[4]; + let __v_39: G = __r_arr[5]; + let __v_40: G = __r_arr[6]; + let __v_41: G = __r_arr[7]; + let __v_42: G = __r_arr[8]; + let __v_43: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_44: G = __r_arr[0]; + let __v_45: G = __r_arr[1]; + let __v_46: G = __r_arr[2]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_16, __v_46]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_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_672] = [__v_50, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_47, __v_48, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_51, __v_49]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __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_658] = { let __args: [G; IN_658] = [__v_14, __v_33]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_34: G = __r_arr[0]; + let __v_35: G = __r_arr[1]; + let __v_36: G = __r_arr[2]; + let __v_37: G = __r_arr[3]; + let __v_38: G = __r_arr[4]; + let __v_39: G = __r_arr[5]; + let __v_40: G = __r_arr[6]; + let __v_41: G = __r_arr[7]; + let __v_42: G = __r_arr[8]; + let __v_43: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_15, __v_43]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __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 __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_16, __v_53]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __v_55: G = __r_arr[1]; + let __v_56: G = __r_arr[2]; + let __v_57: G = __r_arr[3]; + let __v_58: G = __r_arr[4]; + let __v_59: G = __r_arr[5]; + let __v_60: G = __r_arr[6]; + 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_658] = { let __args: [G; IN_658] = [__v_17, __v_63]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_64: G = __r_arr[0]; + let __v_65: G = __r_arr[1]; + let __v_66: G = __r_arr[2]; + let __v_67: G = __r_arr[3]; + let __v_68: G = __r_arr[4]; + let __v_69: G = __r_arr[5]; + let __v_70: G = __r_arr[6]; + let __v_71: G = __r_arr[7]; + let __v_72: G = __r_arr[8]; + let __v_73: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_18, __v_73]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_74: G = __r_arr[0]; + let __v_75: G = __r_arr[1]; + let __v_76: G = __r_arr[2]; + let __v_77: G = __r_arr[3]; + let __v_78: G = __r_arr[4]; + let __v_79: G = __r_arr[5]; + let __v_80: G = __r_arr[6]; + 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_659] = { let __args: [G; IN_659] = [__v_19, __v_83]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_84: G = __r_arr[0]; + let __v_85: G = __r_arr[1]; + let __v_86: G = __r_arr[2]; + let __r_arr: [G; OUT_664] = { let __args: [G; IN_664] = [__v_20, __v_86]; let __cu = unconstrained; if let Some(result) = record.function_queries[664].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_664] = unsafe { *(result.output.as_ptr() as *const [G; OUT_664]) }; __ret } else { aiur_fn_664(__args, record, io_buffer, __cu)? } }; + let __v_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_672] = [__v_90, __v_28, __v_29, __v_31, __v_32, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_84, __v_85, __v_87, __v_88, __v_89]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_660] = { let __args: [G; IN_660] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[660].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_660] = unsafe { *(result.output.as_ptr() as *const [G; OUT_660]) }; __ret } else { aiur_fn_660(__args, record, io_buffer, __cu)? } }; + let __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_658] = { let __args: [G; IN_658] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __v_34: G = __r_arr[3]; + let __v_35: G = __r_arr[4]; + let __v_36: G = __r_arr[5]; + let __v_37: G = __r_arr[6]; + let __v_38: G = __r_arr[7]; + let __v_39: G = __r_arr[8]; + let __v_40: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_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_672] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_662] = { let __args: [G; IN_662] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[662].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_662] = unsafe { *(result.output.as_ptr() as *const [G; OUT_662]) }; __ret } else { aiur_fn_662(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_30]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_31: G = __r_arr[0]; + let __v_32: G = __r_arr[1]; + let __v_33: G = __r_arr[2]; + let __v_34: G = __r_arr[3]; + let __v_35: G = __r_arr[4]; + let __v_36: G = __r_arr[5]; + let __v_37: G = __r_arr[6]; + let __v_38: G = __r_arr[7]; + let __v_39: G = __r_arr[8]; + let __v_40: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_14, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_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_672] = [__v_44, __v_28, __v_29, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_41, __v_42, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_45, __v_43]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __v_37: G = __r_arr[9]; + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __v_40: G = __r_arr[2]; + let __v_41: G = __r_arr[3]; + let __v_42: G = __r_arr[4]; + let __v_43: G = __r_arr[5]; + let __v_44: G = __r_arr[6]; + 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_659] = { let __args: [G; IN_659] = [__v_14, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_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_672] = [__v_51, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_48, __v_49, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_52, __v_50]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __v_37: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_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_672] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __v_37: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_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_672] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 7u64 => { + let __r_arr: [G; OUT_658] = { let __args: [G; IN_658] = [__v_12, __v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[658].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_658] = unsafe { *(result.output.as_ptr() as *const [G; OUT_658]) }; __ret } else { aiur_fn_658(__args, record, io_buffer, __cu)? } }; + let __v_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __v_37: G = __r_arr[9]; + let __r_arr: [G; OUT_659] = { let __args: [G; IN_659] = [__v_13, __v_37]; let __cu = unconstrained; if let Some(result) = record.function_queries[659].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_659] = unsafe { *(result.output.as_ptr() as *const [G; OUT_659]) }; __ret } else { aiur_fn_659(__args, record, io_buffer, __cu)? } }; + let __v_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_672] = [__v_41, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_38, __v_39, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_42, __v_40]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 8u64 => { + let __mc_out___mc_0: [G; 2] = '__mc_0: { match __v_12.as_canonical_u64() { + 0u64 => { + let __v_28: G = G::from_u64(1); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 64] = [__v_28, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29, __v_29]; let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + break '__mc_0 [__v_30, __v_11]; + }, + 1u64 => { + let __r_arr: [G; OUT_73] = { let __args: [G; IN_73] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[73].get_mut(&__args[..]) { 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_28: G = __r_arr[0]; + let __v_29: G = __r_arr[1]; + let __v_30: G = __r_arr[2]; + let __v_31: G = __r_arr[3]; + let __v_32: G = __r_arr[4]; + let __v_33: G = __r_arr[5]; + let __v_34: G = __r_arr[6]; + let __v_35: G = __r_arr[7]; + let __v_36: G = __r_arr[8]; + let __r_arr: [G; OUT_671] = { let __args: [G; IN_671] = [__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[671].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_671] = unsafe { *(result.output.as_ptr() as *const [G; OUT_671]) }; __ret } else { aiur_fn_671(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + break '__mc_0 [__v_37, __v_38]; + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, +} + }; + let __v_28: G = __mc_out___mc_0[0]; + 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_672] = [__v_30, __v_28, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_31, __v_29]; + record.function_queries[672].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_673: usize = 1; +const IN_673: usize = 1; +const OUT_673: usize = 57; +fn aiur_fn_673( + inp: [G; IN_673], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_673], 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 !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_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 __v_11: G = G::from_u64(14); + if (__v_1 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + match __v_2.as_canonical_u64() { + 3u64 => { + 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 !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_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + 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 !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_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_15]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __v_16: G = __r_arr[0]; + let __v_17: G = __r_arr[1]; + let __v_18: G = __r_arr[2]; + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __ret: [G; OUT_673] = [__v_19, __v_12, __v_14, __v_16, __v_17, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_20, __v_18]; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + 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 !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_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = G::from_u64(1); + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_673] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16]; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 5u64 => { + 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 !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_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_657] = { let __args: [G; IN_657] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[657].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_657] = unsafe { *(result.output.as_ptr() as *const [G; OUT_657]) }; __ret } else { aiur_fn_657(__args, record, io_buffer, __cu)? } }; + let __v_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = __r_arr[2]; + let __v_17: G = G::from_u64(2); + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_673] = [__v_17, __v_12, __v_14, __v_15, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_18, __v_16]; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 6u64 => { + 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 !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_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + let __r_arr: [G; OUT_672] = { let __args: [G; IN_672] = [__v_13]; let __cu = unconstrained; if let Some(result) = record.function_queries[672].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_672] = unsafe { *(result.output.as_ptr() as *const [G; OUT_672]) }; __ret } else { aiur_fn_672(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_22: G = __r_arr[8]; + let __v_23: G = __r_arr[9]; + let __v_24: G = __r_arr[10]; + let __v_25: G = __r_arr[11]; + let __v_26: G = __r_arr[12]; + let __v_27: G = __r_arr[13]; + let __v_28: G = __r_arr[14]; + let __v_29: G = __r_arr[15]; + let __v_30: G = __r_arr[16]; + let __v_31: G = __r_arr[17]; + let __v_32: G = __r_arr[18]; + let __v_33: G = __r_arr[19]; + let __v_34: G = __r_arr[20]; + let __v_35: G = __r_arr[21]; + let __v_36: G = __r_arr[22]; + let __v_37: G = __r_arr[23]; + let __v_38: G = __r_arr[24]; + let __v_39: G = __r_arr[25]; + let __v_40: G = __r_arr[26]; + let __v_41: G = __r_arr[27]; + let __v_42: G = __r_arr[28]; + let __v_43: G = __r_arr[29]; + let __v_44: G = __r_arr[30]; + let __v_45: G = __r_arr[31]; + let __v_46: G = __r_arr[32]; + let __v_47: G = __r_arr[33]; + let __v_48: G = __r_arr[34]; + let __v_49: G = __r_arr[35]; + let __v_50: G = __r_arr[36]; + let __v_51: G = __r_arr[37]; + let __v_52: G = __r_arr[38]; + let __v_53: G = __r_arr[39]; + let __v_54: G = __r_arr[40]; + let __v_55: G = __r_arr[41]; + let __v_56: G = __r_arr[42]; + let __v_57: G = __r_arr[43]; + let __v_58: G = __r_arr[44]; + let __v_59: G = __r_arr[45]; + let __v_60: G = __r_arr[46]; + let __v_61: G = __r_arr[47]; + let __v_62: G = __r_arr[48]; + let __v_63: G = __r_arr[49]; + let __v_64: G = __r_arr[50]; + let __v_65: G = __r_arr[51]; + let __v_66: G = __r_arr[52]; + let __v_67: G = __r_arr[53]; + let __v_68: G = __r_arr[54]; + let __v_69: G = G::from_u64(3); + let __ret: [G; OUT_673] = [__v_69, __v_12, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68]; + record.function_queries[673].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 !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_12: G = __r_arr[0]; + let __v_13: G = __r_arr[1]; + 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 !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_14: G = __r_arr[0]; + let __v_15: G = __r_arr[1]; + let __v_16: G = G::from_u64(4); + let __v_17: G = G::from_u64(0); + let __ret: [G; OUT_673] = [__v_16, __v_12, __v_14, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_17, __v_15]; + record.function_queries[673].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_674: usize = 32; +const IN_674: usize = 32; +const OUT_674: usize = 56; +fn aiur_fn_674( + inp: [G; IN_674], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_674], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __info = io_buffer.get_info(__v_32, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_33: G = __io_pair.0; + let __v_34: G = __io_pair.1; + let __v_35: G = G::from_u64(0); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_35, __v_33, __v_34]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __r_arr: [G; OUT_673] = { let __args: [G; IN_673] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[673].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_673] = unsafe { *(result.output.as_ptr() as *const [G; OUT_673]) }; __ret } else { aiur_fn_673(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __v_40: G = __r_arr[3]; + let __v_41: G = __r_arr[4]; + let __v_42: G = __r_arr[5]; + let __v_43: G = __r_arr[6]; + let __v_44: G = __r_arr[7]; + let __v_45: G = __r_arr[8]; + let __v_46: G = __r_arr[9]; + let __v_47: G = __r_arr[10]; + let __v_48: G = __r_arr[11]; + let __v_49: G = __r_arr[12]; + let __v_50: G = __r_arr[13]; + let __v_51: G = __r_arr[14]; + let __v_52: G = __r_arr[15]; + let __v_53: G = __r_arr[16]; + let __v_54: G = __r_arr[17]; + let __v_55: G = __r_arr[18]; + let __v_56: G = __r_arr[19]; + let __v_57: G = __r_arr[20]; + let __v_58: G = __r_arr[21]; + let __v_59: G = __r_arr[22]; + let __v_60: G = __r_arr[23]; + let __v_61: G = __r_arr[24]; + let __v_62: G = __r_arr[25]; + let __v_63: G = __r_arr[26]; + let __v_64: G = __r_arr[27]; + let __v_65: G = __r_arr[28]; + let __v_66: G = __r_arr[29]; + let __v_67: G = __r_arr[30]; + let __v_68: G = __r_arr[31]; + let __v_69: G = __r_arr[32]; + let __v_70: G = __r_arr[33]; + let __v_71: G = __r_arr[34]; + let __v_72: G = __r_arr[35]; + let __v_73: G = __r_arr[36]; + let __v_74: G = __r_arr[37]; + let __v_75: G = __r_arr[38]; + let __v_76: G = __r_arr[39]; + let __v_77: G = __r_arr[40]; + let __v_78: G = __r_arr[41]; + let __v_79: G = __r_arr[42]; + let __v_80: G = __r_arr[43]; + let __v_81: G = __r_arr[44]; + let __v_82: G = __r_arr[45]; + let __v_83: G = __r_arr[46]; + let __v_84: G = __r_arr[47]; + let __v_85: G = __r_arr[48]; + let __v_86: G = __r_arr[49]; + let __v_87: G = __r_arr[50]; + let __v_88: G = __r_arr[51]; + let __v_89: G = __r_arr[52]; + let __v_90: G = __r_arr[53]; + let __v_91: G = __r_arr[54]; + let __v_92: G = __r_arr[55]; + let __v_93: G = __r_arr[56]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_93.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_94: G = __loaded[0]; + let __v_95: G = __loaded[1]; + let __v_96: G = __loaded[2]; + let __v_97: G = G::from_u64(1); + let __v_98: G = G::from_u64(1); + if (__v_94 != __v_97) { + return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_97.as_canonical_u64() }); + } + if (__v_95 != __v_98) { + return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_98.as_canonical_u64() }); + } + if (__v_96 != __v_98) { + return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_98.as_canonical_u64() }); + } + let __ret: [G; OUT_674] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92]; + record.function_queries[674].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_675: usize = 1; +const IN_675: usize = 1; +const OUT_675: usize = 1; +fn aiur_fn_675( + inp: [G; IN_675], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_675], 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = 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_32] = { let __args: [G; IN_32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[32].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_20] = { let __args: [G; IN_20] = [__v_22]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_23: G = __r_arr[0]; + let __ret: [G; OUT_675] = [__v_23]; + record.function_queries[675].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 = 1; +fn aiur_fn_676( + inp: [G; IN_676], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_676], 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_676] = [__v_1]; + record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __v_1: G = G::from_u64(1); + let __ret: [G; OUT_676] = [__v_1]; + record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __v_1: G = G::from_u64(2); + let __ret: [G; OUT_676] = [__v_1]; + record.function_queries[676].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_677: usize = 3; +const IN_677: usize = 3; +const OUT_677: usize = 0; +fn aiur_fn_677( + inp: [G; IN_677], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_677] = []; + record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_676] = { let __args: [G; IN_676] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[676].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_676] = unsafe { *(result.output.as_ptr() as *const [G; OUT_676]) }; __ret } else { aiur_fn_676(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + if (__v_3 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + let __ret: [G; OUT_677] = []; + record.function_queries[677].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_678: usize = 3; +const IN_678: usize = 3; +const OUT_678: usize = 0; +fn aiur_fn_678( + inp: [G; IN_678], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_678], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_678] = []; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_97] = { let __args: [G; IN_97] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[97].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_97] = unsafe { *(result.output.as_ptr() as *const [G; OUT_97]) }; __ret } else { aiur_fn_97(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + 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 !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_4: G = __r_arr[0]; + if (__v_3 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + let __ret: [G; OUT_678] = []; + record.function_queries[678].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_679: usize = 3; +const IN_679: usize = 3; +const OUT_679: usize = 0; +fn aiur_fn_679( + inp: [G; IN_679], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_679], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_679] = []; + record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + if (__v_0 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_2.as_canonical_u64() }); + } + let __ret: [G; OUT_679] = []; + record.function_queries[679].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_680: usize = 17; +const IN_680: usize = 17; +const OUT_680: usize = 0; +fn aiur_fn_680( + inp: [G; IN_680], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_680], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + 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]; + match __v_8.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_680] = []; + record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + if (__v_0 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_0.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); + } + if (__v_1 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_1.as_canonical_u64(), rhs: __v_10.as_canonical_u64() }); + } + if (__v_2 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_2.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + if (__v_3 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + if (__v_4 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_13.as_canonical_u64() }); + } + if (__v_5 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_14.as_canonical_u64() }); + } + if (__v_6 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_15.as_canonical_u64() }); + } + if (__v_7 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); + } + let __ret: [G; OUT_680] = []; + record.function_queries[680].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_681: usize = 3; +const IN_681: usize = 3; +const OUT_681: usize = 0; +fn aiur_fn_681( + inp: [G; IN_681], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_681], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_681] = []; + record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + let __v_8: G = __loaded[5]; + let __v_9: G = __loaded[6]; + let __v_10: G = __loaded[7]; + let __v_11: G = __loaded[8]; + let __v_12: G = __loaded[9]; + let __v_13: G = __loaded[10]; + let __v_14: G = __loaded[11]; + let __v_15: G = __loaded[12]; + let __v_16: G = __loaded[13]; + let __v_17: G = __loaded[14]; + let __v_18: G = __loaded[15]; + let __v_19: G = __loaded[16]; + let __v_20: G = __loaded[17]; + let __v_21: G = __loaded[18]; + let __v_22: G = __loaded[19]; + let __v_23: G = __loaded[20]; + let __v_24: G = __loaded[21]; + let __v_25: G = __loaded[22]; + let __v_26: G = __loaded[23]; + let __v_27: G = __loaded[24]; + let __v_28: G = __loaded[25]; + let __v_29: G = __loaded[26]; + let __v_30: G = __loaded[27]; + let __v_31: G = __loaded[28]; + let __v_32: G = __loaded[29]; + let __v_33: G = __loaded[30]; + let __v_34: G = __loaded[31]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_35: G = __loaded[0]; + let __v_36: G = __loaded[1]; + let __v_37: G = __loaded[2]; + let __v_38: G = __loaded[3]; + let __v_39: G = __loaded[4]; + let __v_40: G = __loaded[5]; + let __v_41: G = __loaded[6]; + let __v_42: G = __loaded[7]; + let __v_43: G = __loaded[8]; + let __v_44: G = __loaded[9]; + let __v_45: G = __loaded[10]; + let __v_46: G = __loaded[11]; + let __v_47: G = __loaded[12]; + let __v_48: G = __loaded[13]; + let __v_49: G = __loaded[14]; + let __v_50: G = __loaded[15]; + let __v_51: G = __loaded[16]; + let __v_52: G = __loaded[17]; + let __v_53: G = __loaded[18]; + let __v_54: G = __loaded[19]; + let __v_55: G = __loaded[20]; + let __v_56: G = __loaded[21]; + let __v_57: G = __loaded[22]; + let __v_58: G = __loaded[23]; + let __v_59: G = __loaded[24]; + let __v_60: G = __loaded[25]; + let __v_61: G = __loaded[26]; + let __v_62: G = __loaded[27]; + let __v_63: G = __loaded[28]; + let __v_64: G = __loaded[29]; + let __v_65: G = __loaded[30]; + let __v_66: G = __loaded[31]; + if (__v_3 != __v_35) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_35.as_canonical_u64() }); + } + if (__v_4 != __v_36) { + return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_36.as_canonical_u64() }); + } + if (__v_5 != __v_37) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_37.as_canonical_u64() }); + } + if (__v_6 != __v_38) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_38.as_canonical_u64() }); + } + if (__v_7 != __v_39) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_39.as_canonical_u64() }); + } + if (__v_8 != __v_40) { + return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_40.as_canonical_u64() }); + } + if (__v_9 != __v_41) { + return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_41.as_canonical_u64() }); + } + if (__v_10 != __v_42) { + return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_42.as_canonical_u64() }); + } + if (__v_11 != __v_43) { + return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_43.as_canonical_u64() }); + } + if (__v_12 != __v_44) { + return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_44.as_canonical_u64() }); + } + if (__v_13 != __v_45) { + return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_45.as_canonical_u64() }); + } + if (__v_14 != __v_46) { + return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_46.as_canonical_u64() }); + } + if (__v_15 != __v_47) { + return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_47.as_canonical_u64() }); + } + if (__v_16 != __v_48) { + return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_48.as_canonical_u64() }); + } + if (__v_17 != __v_49) { + return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_49.as_canonical_u64() }); + } + if (__v_18 != __v_50) { + return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_50.as_canonical_u64() }); + } + if (__v_19 != __v_51) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_51.as_canonical_u64() }); + } + if (__v_20 != __v_52) { + return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_52.as_canonical_u64() }); + } + if (__v_21 != __v_53) { + return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_53.as_canonical_u64() }); + } + if (__v_22 != __v_54) { + return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_54.as_canonical_u64() }); + } + if (__v_23 != __v_55) { + return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_55.as_canonical_u64() }); + } + if (__v_24 != __v_56) { + return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_56.as_canonical_u64() }); + } + if (__v_25 != __v_57) { + return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_57.as_canonical_u64() }); + } + if (__v_26 != __v_58) { + return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_58.as_canonical_u64() }); + } + if (__v_27 != __v_59) { + return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_59.as_canonical_u64() }); + } + if (__v_28 != __v_60) { + return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_60.as_canonical_u64() }); + } + if (__v_29 != __v_61) { + return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_61.as_canonical_u64() }); + } + if (__v_30 != __v_62) { + return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_62.as_canonical_u64() }); + } + if (__v_31 != __v_63) { + return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_63.as_canonical_u64() }); + } + if (__v_32 != __v_64) { + return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_64.as_canonical_u64() }); + } + if (__v_33 != __v_65) { + return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_65.as_canonical_u64() }); + } + if (__v_34 != __v_66) { + return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64() }); + } + let __ret: [G; OUT_681] = []; + record.function_queries[681].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_682: usize = 3; +const IN_682: usize = 3; +const OUT_682: usize = 0; +fn aiur_fn_682( + inp: [G; IN_682], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_682] = []; + record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_675] = { let __args: [G; IN_675] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[675].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_675] = unsafe { *(result.output.as_ptr() as *const [G; OUT_675]) }; __ret } else { aiur_fn_675(__args, record, io_buffer, __cu)? } }; + let __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]; + 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]; + let __v_10: G = __loaded[6]; + let __v_11: G = __loaded[7]; + let __v_12: G = __loaded[8]; + let __v_13: G = __loaded[9]; + let __v_14: G = __loaded[10]; + let __v_15: G = __loaded[11]; + let __v_16: G = __loaded[12]; + let __v_17: G = __loaded[13]; + let __v_18: G = __loaded[14]; + let __v_19: G = __loaded[15]; + let __v_20: G = __loaded[16]; + let __v_21: G = __loaded[17]; + let __v_22: G = __loaded[18]; + let __v_23: G = __loaded[19]; + let __v_24: G = __loaded[20]; + let __v_25: G = __loaded[21]; + let __v_26: G = __loaded[22]; + let __v_27: G = __loaded[23]; + let __v_28: G = __loaded[24]; + let __v_29: G = __loaded[25]; + let __v_30: G = __loaded[26]; + let __v_31: G = __loaded[27]; + let __v_32: G = __loaded[28]; + let __v_33: G = __loaded[29]; + let __v_34: G = __loaded[30]; + let __v_35: G = __loaded[31]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_36: G = __loaded[0]; + let __v_37: G = __loaded[1]; + let __v_38: G = __loaded[2]; + let __v_39: G = __loaded[3]; + let __v_40: G = __loaded[4]; + let __v_41: G = __loaded[5]; + let __v_42: G = __loaded[6]; + let __v_43: G = __loaded[7]; + let __v_44: G = __loaded[8]; + let __v_45: G = __loaded[9]; + let __v_46: G = __loaded[10]; + let __v_47: G = __loaded[11]; + let __v_48: G = __loaded[12]; + let __v_49: G = __loaded[13]; + let __v_50: G = __loaded[14]; + let __v_51: G = __loaded[15]; + let __v_52: G = __loaded[16]; + let __v_53: G = __loaded[17]; + let __v_54: G = __loaded[18]; + let __v_55: G = __loaded[19]; + let __v_56: G = __loaded[20]; + let __v_57: G = __loaded[21]; + let __v_58: G = __loaded[22]; + let __v_59: G = __loaded[23]; + let __v_60: G = __loaded[24]; + let __v_61: G = __loaded[25]; + let __v_62: G = __loaded[26]; + let __v_63: G = __loaded[27]; + let __v_64: G = __loaded[28]; + let __v_65: G = __loaded[29]; + let __v_66: G = __loaded[30]; + let __v_67: G = __loaded[31]; + if (__v_4 != __v_36) { + return Err(ExecError::AssertEqMismatch { lhs: __v_4.as_canonical_u64(), rhs: __v_36.as_canonical_u64() }); + } + if (__v_5 != __v_37) { + return Err(ExecError::AssertEqMismatch { lhs: __v_5.as_canonical_u64(), rhs: __v_37.as_canonical_u64() }); + } + if (__v_6 != __v_38) { + return Err(ExecError::AssertEqMismatch { lhs: __v_6.as_canonical_u64(), rhs: __v_38.as_canonical_u64() }); + } + if (__v_7 != __v_39) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_39.as_canonical_u64() }); + } + if (__v_8 != __v_40) { + return Err(ExecError::AssertEqMismatch { lhs: __v_8.as_canonical_u64(), rhs: __v_40.as_canonical_u64() }); + } + if (__v_9 != __v_41) { + return Err(ExecError::AssertEqMismatch { lhs: __v_9.as_canonical_u64(), rhs: __v_41.as_canonical_u64() }); + } + if (__v_10 != __v_42) { + return Err(ExecError::AssertEqMismatch { lhs: __v_10.as_canonical_u64(), rhs: __v_42.as_canonical_u64() }); + } + if (__v_11 != __v_43) { + return Err(ExecError::AssertEqMismatch { lhs: __v_11.as_canonical_u64(), rhs: __v_43.as_canonical_u64() }); + } + if (__v_12 != __v_44) { + return Err(ExecError::AssertEqMismatch { lhs: __v_12.as_canonical_u64(), rhs: __v_44.as_canonical_u64() }); + } + if (__v_13 != __v_45) { + return Err(ExecError::AssertEqMismatch { lhs: __v_13.as_canonical_u64(), rhs: __v_45.as_canonical_u64() }); + } + if (__v_14 != __v_46) { + return Err(ExecError::AssertEqMismatch { lhs: __v_14.as_canonical_u64(), rhs: __v_46.as_canonical_u64() }); + } + if (__v_15 != __v_47) { + return Err(ExecError::AssertEqMismatch { lhs: __v_15.as_canonical_u64(), rhs: __v_47.as_canonical_u64() }); + } + if (__v_16 != __v_48) { + return Err(ExecError::AssertEqMismatch { lhs: __v_16.as_canonical_u64(), rhs: __v_48.as_canonical_u64() }); + } + if (__v_17 != __v_49) { + return Err(ExecError::AssertEqMismatch { lhs: __v_17.as_canonical_u64(), rhs: __v_49.as_canonical_u64() }); + } + if (__v_18 != __v_50) { + return Err(ExecError::AssertEqMismatch { lhs: __v_18.as_canonical_u64(), rhs: __v_50.as_canonical_u64() }); + } + if (__v_19 != __v_51) { + return Err(ExecError::AssertEqMismatch { lhs: __v_19.as_canonical_u64(), rhs: __v_51.as_canonical_u64() }); + } + if (__v_20 != __v_52) { + return Err(ExecError::AssertEqMismatch { lhs: __v_20.as_canonical_u64(), rhs: __v_52.as_canonical_u64() }); + } + if (__v_21 != __v_53) { + return Err(ExecError::AssertEqMismatch { lhs: __v_21.as_canonical_u64(), rhs: __v_53.as_canonical_u64() }); + } + if (__v_22 != __v_54) { + return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_54.as_canonical_u64() }); + } + if (__v_23 != __v_55) { + return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_55.as_canonical_u64() }); + } + if (__v_24 != __v_56) { + return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_56.as_canonical_u64() }); + } + if (__v_25 != __v_57) { + return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_57.as_canonical_u64() }); + } + if (__v_26 != __v_58) { + return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_58.as_canonical_u64() }); + } + if (__v_27 != __v_59) { + return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_59.as_canonical_u64() }); + } + if (__v_28 != __v_60) { + return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_60.as_canonical_u64() }); + } + if (__v_29 != __v_61) { + return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_61.as_canonical_u64() }); + } + if (__v_30 != __v_62) { + return Err(ExecError::AssertEqMismatch { lhs: __v_30.as_canonical_u64(), rhs: __v_62.as_canonical_u64() }); + } + if (__v_31 != __v_63) { + return Err(ExecError::AssertEqMismatch { lhs: __v_31.as_canonical_u64(), rhs: __v_63.as_canonical_u64() }); + } + if (__v_32 != __v_64) { + return Err(ExecError::AssertEqMismatch { lhs: __v_32.as_canonical_u64(), rhs: __v_64.as_canonical_u64() }); + } + if (__v_33 != __v_65) { + return Err(ExecError::AssertEqMismatch { lhs: __v_33.as_canonical_u64(), rhs: __v_65.as_canonical_u64() }); + } + if (__v_34 != __v_66) { + return Err(ExecError::AssertEqMismatch { lhs: __v_34.as_canonical_u64(), rhs: __v_66.as_canonical_u64() }); + } + if (__v_35 != __v_67) { + return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_67.as_canonical_u64() }); + } + let __ret: [G; OUT_682] = []; + record.function_queries[682].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_683: usize = 2; +const IN_683: usize = 2; +const OUT_683: usize = 0; +fn aiur_fn_683( + inp: [G; IN_683], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_683], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 19] = { let __mq = record.memory_queries.get_mut(&19).ok_or(ExecError::InvalidMemorySize(19))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 19 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 19] = __args[..19].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_21: G = __loaded[0]; + let __v_22: G = __loaded[1]; + let __v_23: G = __loaded[2]; + let __v_24: G = __loaded[3]; + let __v_25: G = __loaded[4]; + let __v_26: G = __loaded[5]; + let __v_27: G = __loaded[6]; + let __v_28: G = __loaded[7]; + let __v_29: G = __loaded[8]; + let __v_30: G = __loaded[9]; + let __v_31: G = __loaded[10]; + match __v_21.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_683] = []; + record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_21: G = __loaded[0]; + let __v_22: G = __loaded[1]; + let __v_23: G = __loaded[2]; + let __v_24: G = __loaded[3]; + let __v_25: G = __loaded[4]; + let __v_26: G = __loaded[5]; + let __v_27: G = __loaded[6]; + let __v_28: G = __loaded[7]; + let __v_29: G = __loaded[8]; + let __v_30: G = __loaded[9]; + let __v_31: G = __loaded[10]; + match __v_21.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + _ => { + match __v_22.as_canonical_u64() { + _ => { + if (__v_22 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_22.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + if (__v_23 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_23.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + if (__v_24 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_24.as_canonical_u64(), rhs: __v_13.as_canonical_u64() }); + } + if (__v_25 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_25.as_canonical_u64(), rhs: __v_14.as_canonical_u64() }); + } + if (__v_26 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_26.as_canonical_u64(), rhs: __v_15.as_canonical_u64() }); + } + if (__v_27 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_27.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); + } + if (__v_28 != __v_17) { + return Err(ExecError::AssertEqMismatch { lhs: __v_28.as_canonical_u64(), rhs: __v_17.as_canonical_u64() }); + } + if (__v_29 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_29.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); + } + let __v_32: G = G::from_u64(0); + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_30, __v_32, __v_19]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_31, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_683] = []; + record.function_queries[683].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_21.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_684: usize = 3; +const IN_684: usize = 3; +const OUT_684: usize = 0; +fn aiur_fn_684( + inp: [G; IN_684], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_684], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_684] = []; + record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_683] = { let __args: [G; IN_683] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[683].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_683] = unsafe { *(result.output.as_ptr() as *const [G; OUT_683]) }; __ret } else { aiur_fn_683(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_684] = []; + record.function_queries[684].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_685: usize = 49; +const IN_685: usize = 49; +const OUT_685: usize = 0; +fn aiur_fn_685( + inp: [G; IN_685], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_685], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __v_49: G = __r_arr[0]; + let __v_50: G = __r_arr[1]; + let __v_51: G = __r_arr[2]; + let __v_52: G = __r_arr[3]; + let __v_53: G = __r_arr[4]; + let __v_54: G = __r_arr[5]; + let __v_55: G = __r_arr[6]; + let __v_56: G = __r_arr[7]; + let __v_57: G = __r_arr[8]; + let __v_58: G = __r_arr[9]; + let __v_59: G = __r_arr[10]; + let __v_60: G = __r_arr[11]; + let __v_61: G = __r_arr[12]; + let __v_62: G = __r_arr[13]; + let __v_63: G = __r_arr[14]; + let __v_64: G = __r_arr[15]; + let __v_65: G = __r_arr[16]; + let __v_66: G = __r_arr[17]; + let __v_67: G = __r_arr[18]; + let __v_68: G = __r_arr[19]; + let __v_69: G = __r_arr[20]; + let __v_70: G = __r_arr[21]; + let __v_71: G = __r_arr[22]; + let __v_72: G = __r_arr[23]; + let __v_73: G = __r_arr[24]; + let __v_74: G = __r_arr[25]; + let __v_75: G = __r_arr[26]; + let __v_76: G = __r_arr[27]; + let __v_77: G = __r_arr[28]; + let __v_78: G = __r_arr[29]; + let __v_79: G = __r_arr[30]; + let __v_80: G = __r_arr[31]; + let __v_81: G = __r_arr[32]; + let __v_82: G = __r_arr[33]; + match __v_9.as_canonical_u64() { + _ => { + match __v_49.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_49, __v_9, __v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_82, __v_47, __v_48]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_685] = []; + record.function_queries[685].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +const INPUT_SIZE_686: usize = 2; +const IN_686: usize = 2; +const OUT_686: usize = 0; +fn aiur_fn_686( + inp: [G; IN_686], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_686], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 50] = { let __mq = record.memory_queries.get_mut(&50).ok_or(ExecError::InvalidMemorySize(50))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 50 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 50] = __args[..50].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + let __v_38: G = __loaded[36]; + let __v_39: G = __loaded[37]; + let __v_40: G = __loaded[38]; + let __v_41: G = __loaded[39]; + let __v_42: G = __loaded[40]; + let __v_43: G = __loaded[41]; + let __v_44: G = __loaded[42]; + let __v_45: G = __loaded[43]; + let __v_46: G = __loaded[44]; + let __v_47: G = __loaded[45]; + let __v_48: G = __loaded[46]; + let __v_49: G = __loaded[47]; + let __v_50: G = __loaded[48]; + let __v_51: G = __loaded[49]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_686] = []; + record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_685] = { let __args: [G; IN_685] = [__v_0, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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[685].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_685] = unsafe { *(result.output.as_ptr() as *const [G; OUT_685]) }; __ret } else { aiur_fn_685(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_686] = []; + record.function_queries[686].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_687: usize = 3; +const IN_687: usize = 3; +const OUT_687: usize = 0; +fn aiur_fn_687( + inp: [G; IN_687], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_687], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_687] = []; + record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_686] = { let __args: [G; IN_686] = [__v_0, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[686].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_686] = unsafe { *(result.output.as_ptr() as *const [G; OUT_686]) }; __ret } else { aiur_fn_686(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_687] = []; + record.function_queries[687].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_688: usize = 99; +const IN_688: usize = 99; +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_688], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + let __v_51: G = inp[51]; + let __v_52: G = inp[52]; + let __v_53: G = inp[53]; + let __v_54: G = inp[54]; + let __v_55: G = inp[55]; + let __v_56: G = inp[56]; + let __v_57: G = inp[57]; + let __v_58: G = inp[58]; + let __v_59: G = inp[59]; + let __v_60: G = inp[60]; + let __v_61: G = inp[61]; + let __v_62: G = inp[62]; + let __v_63: G = inp[63]; + let __v_64: G = inp[64]; + let __v_65: G = inp[65]; + let __v_66: G = inp[66]; + let __v_67: G = inp[67]; + let __v_68: G = inp[68]; + let __v_69: G = inp[69]; + let __v_70: G = inp[70]; + let __v_71: G = inp[71]; + let __v_72: G = inp[72]; + let __v_73: G = inp[73]; + let __v_74: G = inp[74]; + let __v_75: G = inp[75]; + let __v_76: G = inp[76]; + let __v_77: G = inp[77]; + let __v_78: G = inp[78]; + let __v_79: G = inp[79]; + let __v_80: G = inp[80]; + let __v_81: G = inp[81]; + let __v_82: G = inp[82]; + let __v_83: G = inp[83]; + let __v_84: G = inp[84]; + let __v_85: G = inp[85]; + let __v_86: G = inp[86]; + let __v_87: G = inp[87]; + let __v_88: G = inp[88]; + let __v_89: G = inp[89]; + let __v_90: G = inp[90]; + let __v_91: G = inp[91]; + let __v_92: G = inp[92]; + let __v_93: G = inp[93]; + let __v_94: G = inp[94]; + let __v_95: G = inp[95]; + let __v_96: G = inp[96]; + let __v_97: G = inp[97]; + let __v_98: G = inp[98]; + match __v_0.as_canonical_u64() { + 0u64 => { + match __v_45.as_canonical_u64() { + 0u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_11, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_12, __v_61, __v_62]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_688] = []; + record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); + }, + } + }, + 1u64 => { + match __v_45.as_canonical_u64() { + 1u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_3, __v_50, __v_51]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_36, __v_88, __v_89]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_687] = { let __args: [G; IN_687] = [__v_37, __v_90, __v_91]; let __cu = unconstrained; if let Some(result) = record.function_queries[687].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_687] = unsafe { *(result.output.as_ptr() as *const [G; OUT_687]) }; __ret } else { aiur_fn_687(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_688] = []; + record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); + }, + } + }, + 2u64 => { + match __v_45.as_canonical_u64() { + 2u64 => { + match __v_1.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_1, __v_46, __v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_2, __v_48, __v_49]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_43, __v_95, __v_96]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_44, __v_97, __v_98]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_688] = []; + record.function_queries[688].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_0.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_689: usize = 2; +const IN_689: usize = 2; +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_689], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 64] = { let __mq = record.memory_queries.get_mut(&64).ok_or(ExecError::InvalidMemorySize(64))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 64 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 64] = __args[..64].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + let __v_8: G = __loaded[6]; + let __v_9: G = __loaded[7]; + let __v_10: G = __loaded[8]; + let __v_11: G = __loaded[9]; + let __v_12: G = __loaded[10]; + let __v_13: G = __loaded[11]; + let __v_14: G = __loaded[12]; + let __v_15: G = __loaded[13]; + let __v_16: G = __loaded[14]; + let __v_17: G = __loaded[15]; + let __v_18: G = __loaded[16]; + let __v_19: G = __loaded[17]; + let __v_20: G = __loaded[18]; + let __v_21: G = __loaded[19]; + let __v_22: G = __loaded[20]; + let __v_23: G = __loaded[21]; + let __v_24: G = __loaded[22]; + let __v_25: G = __loaded[23]; + let __v_26: G = __loaded[24]; + let __v_27: G = __loaded[25]; + let __v_28: G = __loaded[26]; + let __v_29: G = __loaded[27]; + let __v_30: G = __loaded[28]; + let __v_31: G = __loaded[29]; + let __v_32: G = __loaded[30]; + let __v_33: G = __loaded[31]; + let __v_34: G = __loaded[32]; + let __v_35: G = __loaded[33]; + let __v_36: G = __loaded[34]; + let __v_37: G = __loaded[35]; + let __v_38: G = __loaded[36]; + let __v_39: G = __loaded[37]; + let __v_40: G = __loaded[38]; + let __v_41: G = __loaded[39]; + let __v_42: G = __loaded[40]; + let __v_43: G = __loaded[41]; + let __v_44: G = __loaded[42]; + let __v_45: G = __loaded[43]; + let __v_46: G = __loaded[44]; + let __v_47: G = __loaded[45]; + let __v_48: G = __loaded[46]; + let __v_49: G = __loaded[47]; + let __v_50: G = __loaded[48]; + let __v_51: G = __loaded[49]; + let __v_52: G = __loaded[50]; + let __v_53: G = __loaded[51]; + let __v_54: G = __loaded[52]; + let __v_55: G = __loaded[53]; + let __v_56: G = __loaded[54]; + let __v_57: G = __loaded[55]; + let __v_58: G = __loaded[56]; + let __v_59: G = __loaded[57]; + let __v_60: G = __loaded[58]; + let __v_61: G = __loaded[59]; + let __v_62: G = __loaded[60]; + let __v_63: G = __loaded[61]; + let __v_64: G = __loaded[62]; + let __v_65: G = __loaded[63]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_689] = []; + record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__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[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __v_67: G = __r_arr[1]; + let __v_68: G = __r_arr[2]; + let __v_69: G = __r_arr[3]; + let __v_70: G = __r_arr[4]; + let __v_71: G = __r_arr[5]; + let __v_72: G = __r_arr[6]; + let __v_73: G = __r_arr[7]; + let __v_74: G = __r_arr[8]; + let __v_75: G = __r_arr[9]; + let __v_76: G = __r_arr[10]; + let __v_77: G = __r_arr[11]; + let __v_78: G = __r_arr[12]; + let __v_79: G = __r_arr[13]; + let __v_80: G = __r_arr[14]; + let __v_81: G = __r_arr[15]; + let __v_82: G = __r_arr[16]; + let __v_83: G = __r_arr[17]; + let __v_84: G = __r_arr[18]; + let __v_85: G = __r_arr[19]; + let __v_86: G = __r_arr[20]; + let __v_87: G = __r_arr[21]; + let __v_88: G = __r_arr[22]; + let __v_89: G = __r_arr[23]; + let __v_90: G = __r_arr[24]; + let __v_91: G = __r_arr[25]; + let __v_92: G = __r_arr[26]; + let __v_93: G = __r_arr[27]; + let __v_94: G = __r_arr[28]; + let __v_95: G = __r_arr[29]; + let __v_96: G = __r_arr[30]; + let __v_97: G = __r_arr[31]; + let __v_98: G = __r_arr[32]; + let __v_99: G = __r_arr[33]; + let __v_100: G = __r_arr[34]; + let __v_101: G = __r_arr[35]; + let __v_102: G = __r_arr[36]; + let __v_103: G = __r_arr[37]; + let __v_104: G = __r_arr[38]; + let __v_105: G = __r_arr[39]; + let __v_106: G = __r_arr[40]; + let __v_107: G = __r_arr[41]; + 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_688] = { let __args: [G; IN_688] = [__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[688].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_688] = unsafe { *(result.output.as_ptr() as *const [G; OUT_688]) }; __ret } else { aiur_fn_688(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_0, __v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_689] = []; + record.function_queries[689].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_690: usize = 1; +const IN_690: usize = 1; +const OUT_690: usize = 1; +fn aiur_fn_690( + inp: [G; IN_690], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_690], 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_44] = { let __args: [G; IN_44] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { 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_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_20] = { let __args: [G; IN_20] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __ret: [G; OUT_690] = [__v_8]; + record.function_queries[690].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_691: usize = 2; +const IN_691: usize = 2; +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_691], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = 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_44] = { let __args: [G; IN_44] = [__v_1, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { 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 __r_arr: [G; OUT_44] = { let __args: [G; IN_44] = [__v_0, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[44].get_mut(&__args[..]) { 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 = 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_20] = { let __args: [G; IN_20] = [__v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[20].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_20] = unsafe { *(result.output.as_ptr() as *const [G; OUT_20]) }; __ret } else { aiur_fn_20(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_691] = [__v_10]; + record.function_queries[691].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_692: usize = 1; +const IN_692: usize = 1; +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_692], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __r_arr: [G; OUT_71] = { let __args: [G; IN_71] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[71].get_mut(&__args[..]) { 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_1: G = __r_arr[0]; + let __v_2: G = __r_arr[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_84] = { let __args: [G; IN_84] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[84].get_mut(&__args[..]) { 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_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + let __r_arr: [G; OUT_690] = { let __args: [G; IN_690] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[690].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_690] = unsafe { *(result.output.as_ptr() as *const [G; OUT_690]) }; __ret } else { aiur_fn_690(__args, record, io_buffer, __cu)? } }; + let __v_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_692] = [__v_5, __v_10, __v_4]; + record.function_queries[692].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(0); + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = { let __values: [G; 32] = [__v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_36: G = G::from_u64(1); + let __v_37: G = G::from_u64(1); + let __v_38: G = { let __values: [G; 3] = [__v_36, __v_37, __v_37]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_692] = [__v_35, __v_38, __v_2]; + record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __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_692] = { let __args: [G; IN_692] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __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_691] = { let __args: [G; IN_691] = [__v_3, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[691].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_691] = unsafe { *(result.output.as_ptr() as *const [G; OUT_691]) }; __ret } else { aiur_fn_691(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __ret: [G; OUT_692] = [__v_9, __v_10, __v_8]; + record.function_queries[692].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_693: usize = 1; +const IN_693: usize = 1; +const OUT_693: usize = 1; +fn aiur_fn_693( + inp: [G; IN_693], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_693], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = G::from_u64(1); + let __io_pair: (G, G) = { let __key: [G; 32] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; let __info = io_buffer.get_info(__v_33, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_34: G = __io_pair.0; + let __v_35: G = __io_pair.1; + let __v_36: G = G::from_u64(1); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_36, __v_34, __v_35]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + 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 !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_38: G = __r_arr[0]; + let __v_39: G = __r_arr[1]; + let __v_40: G = __r_arr[2]; + let __v_41: G = __r_arr[3]; + let __v_42: G = __r_arr[4]; + let __v_43: G = __r_arr[5]; + let __v_44: G = __r_arr[6]; + let __v_45: G = __r_arr[7]; + let __v_46: G = __r_arr[8]; + let __v_47: G = __r_arr[9]; + let __v_48: G = G::from_u64(14); + if (__v_38 != __v_48) { + return Err(ExecError::AssertEqMismatch { lhs: __v_38.as_canonical_u64(), rhs: __v_48.as_canonical_u64() }); + } + let __v_49: G = G::from_u64(2); + if (__v_39 != __v_49) { + return Err(ExecError::AssertEqMismatch { lhs: __v_39.as_canonical_u64(), rhs: __v_49.as_canonical_u64() }); + } + let __r_arr: [G; OUT_692] = { let __args: [G; IN_692] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[692].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_692] = unsafe { *(result.output.as_ptr() as *const [G; OUT_692]) }; __ret } else { aiur_fn_692(__args, record, io_buffer, __cu)? } }; + let __v_50: G = __r_arr[0]; + let __v_51: G = __r_arr[1]; + let __v_52: G = __r_arr[2]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_52.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).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_53: G = __loaded[0]; + let __v_54: G = __loaded[1]; + let __v_55: G = __loaded[2]; + let __v_56: G = G::from_u64(1); + let __v_57: G = G::from_u64(1); + if (__v_53 != __v_56) { + return Err(ExecError::AssertEqMismatch { lhs: __v_53.as_canonical_u64(), rhs: __v_56.as_canonical_u64() }); + } + if (__v_54 != __v_57) { + return Err(ExecError::AssertEqMismatch { lhs: __v_54.as_canonical_u64(), rhs: __v_57.as_canonical_u64() }); + } + if (__v_55 != __v_57) { + return Err(ExecError::AssertEqMismatch { lhs: __v_55.as_canonical_u64(), rhs: __v_57.as_canonical_u64() }); + } + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; 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: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_58: G = __loaded[0]; + let __v_59: G = __loaded[1]; + let __v_60: G = __loaded[2]; + let __v_61: G = __loaded[3]; + let __v_62: G = __loaded[4]; + let __v_63: G = __loaded[5]; + let __v_64: G = __loaded[6]; + let __v_65: G = __loaded[7]; + let __v_66: G = __loaded[8]; + let __v_67: G = __loaded[9]; + let __v_68: G = __loaded[10]; + let __v_69: G = __loaded[11]; + let __v_70: G = __loaded[12]; + let __v_71: G = __loaded[13]; + let __v_72: G = __loaded[14]; + let __v_73: G = __loaded[15]; + let __v_74: G = __loaded[16]; + let __v_75: G = __loaded[17]; + let __v_76: G = __loaded[18]; + let __v_77: G = __loaded[19]; + let __v_78: G = __loaded[20]; + let __v_79: G = __loaded[21]; + let __v_80: G = __loaded[22]; + let __v_81: G = __loaded[23]; + let __v_82: G = __loaded[24]; + let __v_83: G = __loaded[25]; + let __v_84: G = __loaded[26]; + let __v_85: G = __loaded[27]; + let __v_86: G = __loaded[28]; + let __v_87: G = __loaded[29]; + let __v_88: G = __loaded[30]; + let __v_89: G = __loaded[31]; + if (__v_58 != __v_1) { + return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_1.as_canonical_u64() }); + } + if (__v_59 != __v_2) { + return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_2.as_canonical_u64() }); + } + if (__v_60 != __v_3) { + return Err(ExecError::AssertEqMismatch { lhs: __v_60.as_canonical_u64(), rhs: __v_3.as_canonical_u64() }); + } + if (__v_61 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_61.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + if (__v_62 != __v_5) { + return Err(ExecError::AssertEqMismatch { lhs: __v_62.as_canonical_u64(), rhs: __v_5.as_canonical_u64() }); + } + if (__v_63 != __v_6) { + return Err(ExecError::AssertEqMismatch { lhs: __v_63.as_canonical_u64(), rhs: __v_6.as_canonical_u64() }); + } + if (__v_64 != __v_7) { + return Err(ExecError::AssertEqMismatch { lhs: __v_64.as_canonical_u64(), rhs: __v_7.as_canonical_u64() }); + } + if (__v_65 != __v_8) { + return Err(ExecError::AssertEqMismatch { lhs: __v_65.as_canonical_u64(), rhs: __v_8.as_canonical_u64() }); + } + if (__v_66 != __v_9) { + return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_9.as_canonical_u64() }); + } + if (__v_67 != __v_10) { + return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_10.as_canonical_u64() }); + } + if (__v_68 != __v_11) { + return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_11.as_canonical_u64() }); + } + if (__v_69 != __v_12) { + return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_12.as_canonical_u64() }); + } + if (__v_70 != __v_13) { + return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_13.as_canonical_u64() }); + } + if (__v_71 != __v_14) { + return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_14.as_canonical_u64() }); + } + if (__v_72 != __v_15) { + return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_15.as_canonical_u64() }); + } + if (__v_73 != __v_16) { + return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_16.as_canonical_u64() }); + } + if (__v_74 != __v_17) { + return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_17.as_canonical_u64() }); + } + if (__v_75 != __v_18) { + return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_18.as_canonical_u64() }); + } + if (__v_76 != __v_19) { + return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_19.as_canonical_u64() }); + } + if (__v_77 != __v_20) { + return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_20.as_canonical_u64() }); + } + if (__v_78 != __v_21) { + return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_21.as_canonical_u64() }); + } + if (__v_79 != __v_22) { + return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_22.as_canonical_u64() }); + } + if (__v_80 != __v_23) { + return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_23.as_canonical_u64() }); + } + if (__v_81 != __v_24) { + return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_24.as_canonical_u64() }); + } + if (__v_82 != __v_25) { + return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_25.as_canonical_u64() }); + } + if (__v_83 != __v_26) { + return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_26.as_canonical_u64() }); + } + if (__v_84 != __v_27) { + return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_27.as_canonical_u64() }); + } + if (__v_85 != __v_28) { + return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_28.as_canonical_u64() }); + } + if (__v_86 != __v_29) { + return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_29.as_canonical_u64() }); + } + if (__v_87 != __v_30) { + return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_30.as_canonical_u64() }); + } + if (__v_88 != __v_31) { + return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_31.as_canonical_u64() }); + } + if (__v_89 != __v_32) { + return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_32.as_canonical_u64() }); + } + let __ret: [G; OUT_693] = [__v_51]; + record.function_queries[693].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +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_694], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_1.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __ret: [G; OUT_694] = [__v_5]; + record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + match __v_5.as_canonical_u64() { + 1u64 => { + let __v_6: G = G::from_u64(1); + let __ret: [G; OUT_694] = [__v_6]; + record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_0, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __ret: [G; OUT_694] = [__v_6]; + record.function_queries[694].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +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_695], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 32] = { let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 32 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 32] = __args[..32].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = G::from_u64(256); + let __v_34: G = (__v_2 * __v_33); + let __v_35: G = G::from_u64(65536); + let __v_36: G = (__v_3 * __v_35); + let __v_37: G = G::from_u64(16777216); + let __v_38: G = (__v_4 * __v_37); + let __v_39: G = (__v_36 + __v_38); + let __v_40: G = (__v_34 + __v_39); + let __v_41: G = (__v_1 + __v_40); + let __ret: [G; OUT_695] = [__v_41]; + record.function_queries[695].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_696: usize = 7; +const IN_696: usize = 7; +const OUT_696: usize = 6; +fn aiur_fn_696( + inp: [G; IN_696], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_696], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_7: G = __loaded[0]; + let __v_8: G = __loaded[1]; + let __v_9: G = __loaded[2]; + match __v_7.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_696] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; + record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __v_10: G = __r_arr[0]; + let __r_arr: [G; OUT_735] = { let __args: [G; IN_735] = [__v_10, __v_8, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[735].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_735] = unsafe { *(result.output.as_ptr() as *const [G; OUT_735]) }; __ret } else { aiur_fn_735(__args, record, io_buffer, __cu)? } }; + let __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_696] = { let __args: [G; IN_696] = [__v_9, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __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_696] = [__v_17, __v_18, __v_19, __v_20, __v_21, __v_22]; + record.function_queries[696].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_7.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_697: usize = 7; +const IN_697: usize = 7; +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_697], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __r_arr: [G; OUT_695] = { let __args: [G; IN_695] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[695].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_695] = unsafe { *(result.output.as_ptr() as *const [G; OUT_695]) }; __ret } else { aiur_fn_695(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(0); + let __v_21: G = G::from_u64(0); + let __v_22: G = G::from_u64(0); + let __v_23: G = G::from_u64(0); + let __v_24: G = G::from_u64(0); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(0); + let __v_30: G = G::from_u64(0); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(0); + let __v_36: G = G::from_u64(0); + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = { let __values: [G; 32] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_7, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_40]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_41: G = __r_arr[0]; + let __r_arr: [G; OUT_127] = { let __args: [G; IN_127] = [__v_41, __v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[127].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_127] = unsafe { *(result.output.as_ptr() as *const [G; OUT_127]) }; __ret } else { aiur_fn_127(__args, record, io_buffer, __cu)? } }; + let __v_42: G = __r_arr[0]; + let __ret: [G; OUT_697] = [__v_42]; + record.function_queries[697].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_698: usize = 4; +const IN_698: usize = 4; +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_698], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __r_arr: [G; OUT_625] = { let __args: [G; IN_625] = [__v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[625].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_625] = unsafe { *(result.output.as_ptr() as *const [G; OUT_625]) }; __ret } else { aiur_fn_625(__args, record, io_buffer, __cu)? } }; + let __v_4: G = G::from_u64(1); + let __v_5: G = G::from_u64(1); + let __r_arr: [G; OUT_696] = { let __args: [G; IN_696] = [__v_3, __v_4, __v_5, __v_5, __v_5, __v_5, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[696].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_696] = unsafe { *(result.output.as_ptr() as *const [G; OUT_696]) }; __ret } else { aiur_fn_696(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = __r_arr[1]; + let __v_8: G = __r_arr[2]; + let __v_9: G = __r_arr[3]; + let __v_10: G = __r_arr[4]; + let __v_11: G = __r_arr[5]; + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_0, __v_1, __v_2, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_698] = []; + record.function_queries[698].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_699: usize = 10; +const IN_699: usize = 10; +const OUT_699: usize = 0; +fn aiur_fn_699( + inp: [G; IN_699], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_699], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_10: G = __loaded[0]; + let __v_11: G = __loaded[1]; + let __v_12: G = __loaded[2]; + match __v_10.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_699] = []; + record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_11.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = __loaded[6]; + let __v_20: G = __loaded[7]; + let __v_21: G = __loaded[8]; + let __v_22: G = __loaded[9]; + let __v_23: G = __loaded[10]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_2, __v_9]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_24: G = __r_arr[0]; + let __r_arr: [G; OUT_697] = { let __args: [G; IN_697] = [__v_24, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[697].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_697] = unsafe { *(result.output.as_ptr() as *const [G; OUT_697]) }; __ret } else { aiur_fn_697(__args, record, io_buffer, __cu)? } }; + let __v_25: G = __r_arr[0]; + match __v_25.as_canonical_u64() { + 1u64 => { + let __v_26: G = G::from_u64(1); + let __v_27: G = (__v_9 + __v_26); + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_699] = []; + record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_9, __v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __v_26: G = G::from_u64(1); + let __v_27: G = (__v_9 + __v_26); + let __r_arr: [G; OUT_699] = { let __args: [G; IN_699] = [__v_12, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_27]; let __cu = unconstrained; if let Some(result) = record.function_queries[699].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_699] = unsafe { *(result.output.as_ptr() as *const [G; OUT_699]) }; __ret } else { aiur_fn_699(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_699] = []; + record.function_queries[699].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_10.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_700: usize = 3; +const IN_700: usize = 3; +const OUT_700: usize = 0; +fn aiur_fn_700( + inp: [G; IN_700], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_700], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + 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 !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = __r_arr[1]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_3, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_700] = []; + record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_3, __v_3, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_700] = []; + record.function_queries[700].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_701: usize = 2; +const IN_701: usize = 2; +const OUT_701: usize = 0; +fn aiur_fn_701( + inp: [G; IN_701], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_701], 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_693] = { let __args: [G; IN_693] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __r_arr: [G; OUT_694] = { let __args: [G; IN_694] = [__v_1, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[694].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_694] = unsafe { *(result.output.as_ptr() as *const [G; OUT_694]) }; __ret } else { aiur_fn_694(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __v_4: G = G::from_u64(1); + if (__v_3 != __v_4) { + return Err(ExecError::AssertEqMismatch { lhs: __v_3.as_canonical_u64(), rhs: __v_4.as_canonical_u64() }); + } + let __ret: [G; OUT_701] = []; + record.function_queries[701].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_702: usize = 3; +const IN_702: usize = 3; +const OUT_702: usize = 0; +fn aiur_fn_702( + inp: [G; IN_702], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_702], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __v_3: G = __r_arr[0]; + let __r_arr: [G; OUT_194] = { let __args: [G; IN_194] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[194].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_194] = unsafe { *(result.output.as_ptr() as *const [G; OUT_194]) }; __ret } else { aiur_fn_194(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_655] = { let __args: [G; IN_655] = [__v_4, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[655].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_655] = unsafe { *(result.output.as_ptr() as *const [G; OUT_655]) }; __ret } else { aiur_fn_655(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_702] = []; + record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_693] = { let __args: [G; IN_693] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[693].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_693] = unsafe { *(result.output.as_ptr() as *const [G; OUT_693]) }; __ret } else { aiur_fn_693(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __r_arr: [G; OUT_698] = { let __args: [G; IN_698] = [__v_4, __v_4, __v_5, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[698].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_698] = unsafe { *(result.output.as_ptr() as *const [G; OUT_698]) }; __ret } else { aiur_fn_698(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_702] = []; + record.function_queries[702].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_703: usize = 55; +const IN_703: usize = 55; +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_703], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = inp[32]; + let __v_33: G = inp[33]; + let __v_34: G = inp[34]; + let __v_35: G = inp[35]; + let __v_36: G = inp[36]; + let __v_37: G = inp[37]; + let __v_38: G = inp[38]; + let __v_39: G = inp[39]; + let __v_40: G = inp[40]; + let __v_41: G = inp[41]; + let __v_42: G = inp[42]; + let __v_43: G = inp[43]; + let __v_44: G = inp[44]; + let __v_45: G = inp[45]; + let __v_46: G = inp[46]; + let __v_47: G = inp[47]; + let __v_48: G = inp[48]; + let __v_49: G = inp[49]; + let __v_50: G = inp[50]; + let __v_51: G = inp[51]; + let __v_52: G = inp[52]; + let __v_53: G = inp[53]; + let __v_54: G = inp[54]; + let __r_arr: [G; OUT_124] = { let __args: [G; IN_124] = [__v_0]; let __cu = unconstrained; if let Some(result) = record.function_queries[124].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_124] = unsafe { *(result.output.as_ptr() as *const [G; OUT_124]) }; __ret } else { aiur_fn_124(__args, record, io_buffer, __cu)? } }; + let __v_55: G = __r_arr[0]; + let __v_56: G = __r_arr[1]; + let __v_57: G = __r_arr[2]; + let __v_58: G = __r_arr[3]; + let __v_59: G = __r_arr[4]; + let __v_60: G = __r_arr[5]; + let __v_61: G = __r_arr[6]; + let __v_62: G = __r_arr[7]; + let __v_63: G = __r_arr[8]; + let __v_64: G = __r_arr[9]; + let __v_65: G = __r_arr[10]; + let __v_66: G = __r_arr[11]; + let __v_67: G = __r_arr[12]; + let __v_68: G = __r_arr[13]; + let __v_69: G = __r_arr[14]; + let __v_70: G = __r_arr[15]; + let __v_71: G = __r_arr[16]; + let __v_72: G = __r_arr[17]; + let __v_73: G = __r_arr[18]; + let __v_74: G = __r_arr[19]; + let __v_75: G = __r_arr[20]; + let __v_76: G = __r_arr[21]; + let __v_77: G = __r_arr[22]; + let __v_78: G = __r_arr[23]; + let __v_79: G = __r_arr[24]; + let __v_80: G = __r_arr[25]; + let __v_81: G = __r_arr[26]; + let __v_82: G = __r_arr[27]; + let __v_83: G = __r_arr[28]; + let __v_84: G = __r_arr[29]; + let __v_85: G = __r_arr[30]; + let __v_86: G = __r_arr[31]; + let __v_87: G = __r_arr[32]; + let __v_88: G = __r_arr[33]; + let __v_89: G = __r_arr[34]; + let __v_90: G = __r_arr[35]; + let __v_91: G = __r_arr[36]; + let __v_92: G = __r_arr[37]; + let __v_93: G = __r_arr[38]; + let __v_94: G = __r_arr[39]; + let __v_95: G = __r_arr[40]; + let __v_96: G = __r_arr[41]; + let __v_97: G = __r_arr[42]; + let __v_98: G = __r_arr[43]; + let __v_99: G = __r_arr[44]; + let __v_100: G = __r_arr[45]; + let __v_101: G = __r_arr[46]; + let __v_102: G = __r_arr[47]; + match __v_55.as_canonical_u64() { + _ => { + match __v_55.as_canonical_u64() { + 0u64 => { + match __v_1.as_canonical_u64() { + 0u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_677] = { let __args: [G; IN_677] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[677].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_677] = unsafe { *(result.output.as_ptr() as *const [G; OUT_677]) }; __ret } else { aiur_fn_677(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_66, __v_15, __v_16]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_67, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].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() { + 1u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_57, __v_4, __v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_98, __v_51, __v_52]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_684] = { let __args: [G; IN_684] = [__v_99, __v_53, __v_54]; let __cu = unconstrained; if let Some(result) = record.function_queries[684].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_684] = unsafe { *(result.output.as_ptr() as *const [G; OUT_684]) }; __ret } else { aiur_fn_684(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].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() { + 2u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_679] = { let __args: [G; IN_679] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[679].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_679] = unsafe { *(result.output.as_ptr() as *const [G; OUT_679]) }; __ret } else { aiur_fn_679(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__v_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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].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() { + 3u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_678] = { let __args: [G; IN_678] = [__v_56, __v_2, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[678].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_678] = unsafe { *(result.output.as_ptr() as *const [G; OUT_678]) }; __ret } else { aiur_fn_678(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_682] = { let __args: [G; IN_682] = [__v_65, __v_13, __v_14]; let __cu = unconstrained; if let Some(result) = record.function_queries[682].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_682] = unsafe { *(result.output.as_ptr() as *const [G; OUT_682]) }; __ret } else { aiur_fn_682(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 4u64 => { + match __v_1.as_canonical_u64() { + 4u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_72, __v_20, __v_21]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 5u64 => { + match __v_1.as_canonical_u64() { + 5u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 6u64 => { + match __v_1.as_canonical_u64() { + 6u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 7u64 => { + match __v_1.as_canonical_u64() { + 7u64 => { + match __v_56.as_canonical_u64() { + _ => { + let __r_arr: [G; OUT_680] = { let __args: [G; IN_680] = [__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[680].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_680] = unsafe { *(result.output.as_ptr() as *const [G; OUT_680]) }; __ret } else { aiur_fn_680(__args, record, io_buffer, __cu)? } }; + let __r_arr: [G; OUT_681] = { let __args: [G; IN_681] = [__v_64, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[681].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_681] = unsafe { *(result.output.as_ptr() as *const [G; OUT_681]) }; __ret } else { aiur_fn_681(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + 8u64 => { + match __v_1.as_canonical_u64() { + 8u64 => { + let __r_arr: [G; OUT_689] = { let __args: [G; IN_689] = [__v_56, __v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[689].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_689] = unsafe { *(result.output.as_ptr() as *const [G; OUT_689]) }; __ret } else { aiur_fn_689(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_703] = []; + record.function_queries[703].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_55.as_canonical_u64())); + }, + } + }, + } + }) +} + +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_704], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = 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 __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() }); + } + let __ret: [G; OUT_704] = []; + record.function_queries[704].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_705: usize = 32; +const IN_705: usize = 32; +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_705], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __r_arr: [G; OUT_674] = { let __args: [G; IN_674] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_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[674].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_674] = unsafe { *(result.output.as_ptr() as *const [G; OUT_674]) }; __ret } else { aiur_fn_674(__args, record, io_buffer, __cu)? } }; + let __v_32: G = __r_arr[0]; + let __v_33: G = __r_arr[1]; + let __v_34: G = __r_arr[2]; + let __v_35: G = __r_arr[3]; + let __v_36: G = __r_arr[4]; + let __v_37: G = __r_arr[5]; + let __v_38: G = __r_arr[6]; + let __v_39: G = __r_arr[7]; + let __v_40: G = __r_arr[8]; + let __v_41: G = __r_arr[9]; + let __v_42: G = __r_arr[10]; + let __v_43: G = __r_arr[11]; + let __v_44: G = __r_arr[12]; + let __v_45: G = __r_arr[13]; + let __v_46: G = __r_arr[14]; + let __v_47: G = __r_arr[15]; + let __v_48: G = __r_arr[16]; + let __v_49: G = __r_arr[17]; + let __v_50: G = __r_arr[18]; + let __v_51: G = __r_arr[19]; + let __v_52: G = __r_arr[20]; + let __v_53: G = __r_arr[21]; + let __v_54: G = __r_arr[22]; + let __v_55: G = __r_arr[23]; + let __v_56: G = __r_arr[24]; + let __v_57: G = __r_arr[25]; + let __v_58: G = __r_arr[26]; + let __v_59: G = __r_arr[27]; + let __v_60: G = __r_arr[28]; + let __v_61: G = __r_arr[29]; + let __v_62: G = __r_arr[30]; + let __v_63: G = __r_arr[31]; + let __v_64: G = __r_arr[32]; + let __v_65: G = __r_arr[33]; + let __v_66: G = __r_arr[34]; + let __v_67: G = __r_arr[35]; + let __v_68: G = __r_arr[36]; + let __v_69: G = __r_arr[37]; + let __v_70: G = __r_arr[38]; + let __v_71: G = __r_arr[39]; + let __v_72: G = __r_arr[40]; + let __v_73: G = __r_arr[41]; + let __v_74: G = __r_arr[42]; + let __v_75: G = __r_arr[43]; + let __v_76: G = __r_arr[44]; + let __v_77: G = __r_arr[45]; + let __v_78: G = __r_arr[46]; + let __v_79: G = __r_arr[47]; + let __v_80: G = __r_arr[48]; + let __v_81: G = __r_arr[49]; + let __v_82: G = __r_arr[50]; + let __v_83: G = __r_arr[51]; + let __v_84: G = __r_arr[52]; + let __v_85: G = __r_arr[53]; + let __v_86: G = __r_arr[54]; + let __v_87: G = __r_arr[55]; + match __v_32.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_704] = { let __args: [G; IN_704] = [__v_33, __v_34, __v_35, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[704].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_704] = unsafe { *(result.output.as_ptr() as *const [G; OUT_704]) }; __ret } else { aiur_fn_704(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 1u64 => { + let __r_arr: [G; OUT_700] = { let __args: [G; IN_700] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[700].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_700] = unsafe { *(result.output.as_ptr() as *const [G; OUT_700]) }; __ret } else { aiur_fn_700(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 2u64 => { + let __r_arr: [G; OUT_702] = { let __args: [G; IN_702] = [__v_33, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[702].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_702] = unsafe { *(result.output.as_ptr() as *const [G; OUT_702]) }; __ret } else { aiur_fn_702(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 3u64 => { + let __r_arr: [G; OUT_703] = { let __args: [G; IN_703] = [__v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; let __cu = unconstrained; if let Some(result) = record.function_queries[703].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_703] = unsafe { *(result.output.as_ptr() as *const [G; OUT_703]) }; __ret } else { aiur_fn_703(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 4u64 => { + let __r_arr: [G; OUT_701] = { let __args: [G; IN_701] = [__v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[701].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_701] = unsafe { *(result.output.as_ptr() as *const [G; OUT_701]) }; __ret } else { aiur_fn_701(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_705] = []; + record.function_queries[705].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_32.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_706: usize = 32; +const IN_706: usize = 32; +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_706], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __v_9: G = inp[9]; + let __v_10: G = inp[10]; + let __v_11: G = inp[11]; + let __v_12: G = inp[12]; + let __v_13: G = inp[13]; + let __v_14: G = inp[14]; + let __v_15: G = inp[15]; + let __v_16: G = inp[16]; + let __v_17: G = inp[17]; + let __v_18: G = inp[18]; + let __v_19: G = inp[19]; + let __v_20: G = inp[20]; + let __v_21: G = inp[21]; + let __v_22: G = inp[22]; + let __v_23: G = inp[23]; + let __v_24: G = inp[24]; + let __v_25: G = inp[25]; + let __v_26: G = inp[26]; + let __v_27: G = inp[27]; + let __v_28: G = inp[28]; + let __v_29: G = inp[29]; + let __v_30: G = inp[30]; + let __v_31: G = inp[31]; + let __v_32: G = { let __values: [G; 32] = [__v_0, __v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31]; let __mq = record.memory_queries.get_mut(&32).ok_or(ExecError::InvalidMemorySize(32))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_193] = { let __args: [G; IN_193] = [__v_32]; let __cu = unconstrained; if let Some(result) = record.function_queries[193].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_193] = unsafe { *(result.output.as_ptr() as *const [G; OUT_193]) }; __ret } else { aiur_fn_193(__args, record, io_buffer, __cu)? } }; + let __v_33: G = __r_arr[0]; + let __v_34: G = __r_arr[1]; + let __v_35: G = G::from_u64(0); + let __r_arr: [G; OUT_453] = { let __args: [G; IN_453] = [__v_32, __v_34, __v_35]; let __cu = unconstrained; if let Some(result) = record.function_queries[453].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_453] = unsafe { *(result.output.as_ptr() as *const [G; OUT_453]) }; __ret } else { aiur_fn_453(__args, record, io_buffer, __cu)? } }; + let __v_36: G = __r_arr[0]; + let __r_arr: [G; OUT_718] = { let __args: [G; IN_718] = [__v_33, __v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[718].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_718] = unsafe { *(result.output.as_ptr() as *const [G; OUT_718]) }; __ret } else { aiur_fn_718(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __loaded: [G; 11] = { let __mq = record.memory_queries.get_mut(&11).ok_or(ExecError::InvalidMemorySize(11))?; let __ptr_u64 = __v_37.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 11 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 11] = __args[..11].try_into().unwrap(); __arr }; + let __v_38: G = __loaded[0]; + let __v_39: G = __loaded[1]; + let __v_40: G = __loaded[2]; + let __v_41: G = __loaded[3]; + let __v_42: G = __loaded[4]; + let __v_43: G = __loaded[5]; + let __v_44: G = __loaded[6]; + let __v_45: G = __loaded[7]; + let __v_46: G = __loaded[8]; + let __v_47: G = __loaded[9]; + let __v_48: G = __loaded[10]; + let __r_arr: [G; OUT_652] = { let __args: [G; IN_652] = [__v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_36, __v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[652].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_652] = unsafe { *(result.output.as_ptr() as *const [G; OUT_652]) }; __ret } else { aiur_fn_652(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_706] = []; + record.function_queries[706].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_707: usize = 1; +const IN_707: usize = 1; +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_707], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_707] = []; + record.function_queries[707].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 __v_3: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_2]; let __info = io_buffer.get_info(__v_3, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_4: G = __io_pair.0; + let __v_5: G = __io_pair.1; + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_13: G = __r_arr[5]; + let __v_14: G = __r_arr[6]; + let __v_15: G = __r_arr[7]; + let __v_16: G = __r_arr[8]; + let __v_17: G = __r_arr[9]; + let __v_18: G = __r_arr[10]; + let __v_19: G = __r_arr[11]; + let __v_20: G = __r_arr[12]; + let __v_21: G = __r_arr[13]; + let __v_22: G = __r_arr[14]; + let __v_23: G = __r_arr[15]; + let __v_24: G = __r_arr[16]; + let __v_25: G = __r_arr[17]; + let __v_26: G = __r_arr[18]; + let __v_27: G = __r_arr[19]; + let __v_28: G = __r_arr[20]; + let __v_29: G = __r_arr[21]; + let __v_30: G = __r_arr[22]; + let __v_31: G = __r_arr[23]; + let __v_32: G = __r_arr[24]; + let __v_33: G = __r_arr[25]; + let __v_34: G = __r_arr[26]; + let __v_35: G = __r_arr[27]; + let __v_36: G = __r_arr[28]; + let __v_37: G = __r_arr[29]; + let __v_38: G = __r_arr[30]; + let __v_39: G = __r_arr[31]; + let __v_40: G = __r_arr[32]; + let __v_41: G = __r_arr[33]; + let __v_42: G = __r_arr[34]; + let __v_43: G = __r_arr[35]; + let __v_44: G = __r_arr[36]; + let __v_45: G = __r_arr[37]; + let __v_46: G = __r_arr[38]; + let __v_47: G = __r_arr[39]; + let __v_48: G = __r_arr[40]; + let __v_49: G = __r_arr[41]; + let __v_50: G = __r_arr[42]; + let __v_51: G = __r_arr[43]; + let __v_52: G = __r_arr[44]; + let __v_53: G = __r_arr[45]; + let __v_54: G = __r_arr[46]; + let __v_55: G = __r_arr[47]; + let __v_56: G = __r_arr[48]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_57: G = __loaded[0]; + let __v_58: G = __loaded[1]; + let __v_59: G = __loaded[2]; + let __v_60: G = G::from_u64(1); + let __v_61: G = G::from_u64(1); + if (__v_57 != __v_60) { + return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_60.as_canonical_u64() }); + } + if (__v_58 != __v_61) { + return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_61.as_canonical_u64() }); + } + if (__v_59 != __v_61) { + return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_61.as_canonical_u64() }); + } + let __v_62: G = G::from_u64(1); + let __v_63: G = G::from_u64(1); + let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + if (__v_7 != __v_65) { + return Err(ExecError::AssertEqMismatch { lhs: __v_7.as_canonical_u64(), rhs: __v_65.as_canonical_u64() }); + } + let __r_arr: [G; OUT_707] = { let __args: [G; IN_707] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[707].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_707] = unsafe { *(result.output.as_ptr() as *const [G; OUT_707]) }; __ret } else { aiur_fn_707(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_707] = []; + record.function_queries[707].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_708: usize = 0; +const IN_708: usize = 0; +const OUT_708: usize = 0; +fn aiur_fn_708( + inp: [G; IN_708], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_708], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = G::from_u64(0); + let __v_1: G = G::from_u64(0); + let __v_2: G = G::from_u64(4); + let __v_3: G = G::from_u64(0); + let __v_4: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_0, __v_1, __v_1, __v_2, __v_3, __v_4]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_5: G = __r_arr[0]; + 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() }); + } + let __v_7: G = G::from_u64(4); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(4); + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_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() }); + } + let __v_15: G = G::from_u64(4); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(4); + let __v_19: G = G::from_u64(1); + let __v_20: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_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() }); + } + let __v_23: G = G::from_u64(1); + let __v_24: G = G::from_u64(4); + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(0); + let __v_27: G = { let __values: [G; 3] = [__v_24, __v_25, __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 __v_29: G = G::from_u64(1); + let __v_30: G = G::from_u64(4); + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(0); + let __v_33: G = { let __values: [G; 3] = [__v_30, __v_31, __v_32]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_23, __v_27, __v_28, __v_29, __v_33, __v_34]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_35: G = __r_arr[0]; + let __v_36: G = G::from_u64(1); + if (__v_35 != __v_36) { + return Err(ExecError::AssertEqMismatch { lhs: __v_35.as_canonical_u64(), rhs: __v_36.as_canonical_u64() }); + } + let __v_37: G = G::from_u64(1); + let __v_38: G = G::from_u64(4); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = { let __values: [G; 3] = [__v_38, __v_39, __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 = G::from_u64(0); + let __v_43: G = G::from_u64(4); + let __v_44: G = G::from_u64(0); + let __v_45: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_37, __v_41, __v_42, __v_43, __v_44, __v_45]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_46: G = __r_arr[0]; + let __v_47: G = G::from_u64(0); + if (__v_46 != __v_47) { + return Err(ExecError::AssertEqMismatch { lhs: __v_46.as_canonical_u64(), rhs: __v_47.as_canonical_u64() }); + } + let __v_48: G = G::from_u64(4); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(1); + let __v_52: G = G::from_u64(4); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = { let __values: [G; 3] = [__v_52, __v_53, __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 = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_48, __v_49, __v_50, __v_51, __v_55, __v_56]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_57: G = __r_arr[0]; + let __v_58: G = G::from_u64(1); + if (__v_57 != __v_58) { + return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_58.as_canonical_u64() }); + } + let __v_59: G = G::from_u64(2); + let __v_60: G = G::from_u64(4); + let __v_61: G = G::from_u64(0); + let __v_62: G = G::from_u64(0); + let __v_63: G = { let __values: [G; 3] = [__v_60, __v_61, __v_62]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_64: G = G::from_u64(4); + let __v_65: G = G::from_u64(1); + let __v_66: G = G::from_u64(0); + let __v_67: G = { let __values: [G; 3] = [__v_64, __v_65, __v_66]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_59, __v_63, __v_67, __v_59, __v_63, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_68: G = __r_arr[0]; + 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() }); + } + let __v_70: G = G::from_u64(4); + let __v_71: G = G::from_u64(0); + let __v_72: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_70, __v_71, __v_72, __v_59, __v_63, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_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() }); + } + let __v_75: G = G::from_u64(4); + let __v_76: G = G::from_u64(0); + let __v_77: G = G::from_u64(0); + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_59, __v_63, __v_67, __v_75, __v_76, __v_77]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_78: G = __r_arr[0]; + let __v_79: G = G::from_u64(0); + if (__v_78 != __v_79) { + return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_79.as_canonical_u64() }); + } + let __v_80: G = G::from_u64(3); + let __v_81: G = G::from_u64(4); + let __v_82: G = G::from_u64(0); + let __v_83: G = G::from_u64(0); + let __v_84: G = { let __values: [G; 3] = [__v_81, __v_82, __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 = G::from_u64(4); + let __v_86: G = G::from_u64(1); + let __v_87: G = G::from_u64(0); + let __v_88: G = { let __values: [G; 3] = [__v_85, __v_86, __v_87]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_80, __v_84, __v_88, __v_59, __v_63, __v_67]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_89: G = __r_arr[0]; + let __v_90: G = G::from_u64(1); + if (__v_89 != __v_90) { + return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_90.as_canonical_u64() }); + } + let __r_arr: [G; OUT_226] = { let __args: [G; IN_226] = [__v_59, __v_63, __v_67, __v_80, __v_84, __v_88]; let __cu = unconstrained; if let Some(result) = record.function_queries[226].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_226] = unsafe { *(result.output.as_ptr() as *const [G; OUT_226]) }; __ret } else { aiur_fn_226(__args, record, io_buffer, __cu)? } }; + let __v_91: G = __r_arr[0]; + let __v_92: G = G::from_u64(0); + if (__v_91 != __v_92) { + return Err(ExecError::AssertEqMismatch { lhs: __v_91.as_canonical_u64(), rhs: __v_92.as_canonical_u64() }); + } + let __v_93: G = G::from_u64(1); + let __v_94: G = G::from_u64(4); + let __v_95: G = G::from_u64(0); + let __v_96: G = G::from_u64(0); + let __v_97: G = { let __values: [G; 3] = [__v_94, __v_95, __v_96]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_98: G = G::from_u64(0); + let __v_99: G = G::from_u64(2); + let __v_100: G = G::from_u64(1); + let __v_101: G = G::from_u64(0); + let __v_102: G = G::from_u64(0); + let __v_103: G = { let __values: [G; 3] = [__v_101, __v_102, __v_102]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_104: G = G::from_u64(0); + let __v_105: G = { let __values: [G; 3] = [__v_100, __v_103, __v_104]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_106: G = G::from_u64(3); + let __v_107: G = G::from_u64(1); + let __v_108: G = G::from_u64(4); + let __v_109: G = G::from_u64(0); + let __v_110: G = G::from_u64(0); + let __v_111: G = { let __values: [G; 3] = [__v_108, __v_109, __v_110]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_112: G = G::from_u64(0); + let __v_113: G = { let __values: [G; 3] = [__v_107, __v_111, __v_112]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_114: G = G::from_u64(4); + let __v_115: G = G::from_u64(0); + let __v_116: G = G::from_u64(0); + let __v_117: G = { let __values: [G; 3] = [__v_114, __v_115, __v_116]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_118: G = { let __values: [G; 3] = [__v_106, __v_113, __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_227] = { let __args: [G; IN_227] = [__v_93, __v_97, __v_98, __v_99, __v_105, __v_118]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { 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_119: G = __r_arr[0]; + let __v_120: G = G::from_u64(1); + if (__v_119 != __v_120) { + return Err(ExecError::AssertEqMismatch { lhs: __v_119.as_canonical_u64(), rhs: __v_120.as_canonical_u64() }); + } + let __v_121: G = G::from_u64(3); + let __v_122: G = G::from_u64(4); + let __v_123: G = G::from_u64(0); + let __v_124: G = G::from_u64(0); + let __v_125: G = { let __values: [G; 3] = [__v_122, __v_123, __v_124]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_126: G = G::from_u64(4); + let __v_127: G = G::from_u64(0); + let __v_128: G = G::from_u64(0); + let __v_129: G = { let __values: [G; 3] = [__v_126, __v_127, __v_128]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_130: G = G::from_u64(4); + let __v_131: G = G::from_u64(0); + let __v_132: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_121, __v_125, __v_129, __v_130, __v_131, __v_132]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { 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_133: G = __r_arr[0]; + let __v_134: G = G::from_u64(1); + if (__v_133 != __v_134) { + return Err(ExecError::AssertEqMismatch { lhs: __v_133.as_canonical_u64(), rhs: __v_134.as_canonical_u64() }); + } + let __v_135: G = G::from_u64(2); + let __v_136: G = G::from_u64(4); + let __v_137: G = G::from_u64(0); + let __v_138: G = G::from_u64(0); + let __v_139: G = { let __values: [G; 3] = [__v_136, __v_137, __v_138]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_140: G = G::from_u64(0); + let __v_141: G = G::from_u64(0); + let __v_142: G = { let __values: [G; 3] = [__v_140, __v_141, __v_141]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_143: G = G::from_u64(4); + let __v_144: G = G::from_u64(0); + let __v_145: G = G::from_u64(0); + let __r_arr: [G; OUT_227] = { let __args: [G; IN_227] = [__v_135, __v_139, __v_142, __v_143, __v_144, __v_145]; let __cu = unconstrained; if let Some(result) = record.function_queries[227].get_mut(&__args[..]) { 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_146: G = __r_arr[0]; + let __v_147: G = G::from_u64(1); + if (__v_146 != __v_147) { + return Err(ExecError::AssertEqMismatch { lhs: __v_146.as_canonical_u64(), rhs: __v_147.as_canonical_u64() }); + } + let __v_148: G = G::from_u64(1); + let __v_149: G = G::from_u64(4); + let __v_150: G = G::from_u64(1); + let __v_151: G = G::from_u64(0); + let __v_152: G = { let __values: [G; 3] = [__v_149, __v_150, __v_151]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_153: G = G::from_u64(0); + let __v_154: G = G::from_u64(4); + let __v_155: G = G::from_u64(0); + let __v_156: G = G::from_u64(0); + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_154, __v_155, __v_156, __v_148, __v_152, __v_153]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_157: G = __r_arr[0]; + let __v_158: G = __r_arr[1]; + let __v_159: G = __r_arr[2]; + let __v_160: G = G::from_u64(2); + let __v_161: G = G::from_u64(4); + let __v_162: G = G::from_u64(0); + let __v_163: G = G::from_u64(0); + let __v_164: G = { let __values: [G; 3] = [__v_161, __v_162, __v_163]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_165: G = { let __values: [G; 3] = [__v_148, __v_152, __v_153]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_157, __v_158, __v_159, __v_160, __v_164, __v_165]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_166: G = __r_arr[0]; + let __v_167: G = G::from_u64(1); + if (__v_166 != __v_167) { + return Err(ExecError::AssertEqMismatch { lhs: __v_166.as_canonical_u64(), rhs: __v_167.as_canonical_u64() }); + } + let __v_168: G = G::from_u64(4); + let __v_169: G = G::from_u64(0); + let __v_170: G = G::from_u64(0); + let __v_171: G = G::from_u64(0); + let __v_172: G = G::from_u64(0); + let __r_arr: [G; OUT_229] = { let __args: [G; IN_229] = [__v_168, __v_169, __v_170, __v_171, __v_172, __v_172]; let __cu = unconstrained; if let Some(result) = record.function_queries[229].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_229] = unsafe { *(result.output.as_ptr() as *const [G; OUT_229]) }; __ret } else { aiur_fn_229(__args, record, io_buffer, __cu)? } }; + let __v_173: G = __r_arr[0]; + let __v_174: G = __r_arr[1]; + let __v_175: G = __r_arr[2]; + let __v_176: G = G::from_u64(0); + let __v_177: G = G::from_u64(0); + let __r_arr: [G; OUT_202] = { let __args: [G; IN_202] = [__v_173, __v_174, __v_175, __v_176, __v_177, __v_177]; let __cu = unconstrained; if let Some(result) = record.function_queries[202].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_202] = unsafe { *(result.output.as_ptr() as *const [G; OUT_202]) }; __ret } else { aiur_fn_202(__args, record, io_buffer, __cu)? } }; + let __v_178: G = __r_arr[0]; + let __v_179: G = G::from_u64(1); + if (__v_178 != __v_179) { + return Err(ExecError::AssertEqMismatch { lhs: __v_178.as_canonical_u64(), rhs: __v_179.as_canonical_u64() }); + } + let __ret: [G; OUT_708] = []; + record.function_queries[708].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_709: usize = 0; +const IN_709: usize = 0; +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_709], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __r_arr: [G; OUT_708] = { let __args: [G; IN_708] = []; let __cu = unconstrained; if let Some(result) = record.function_queries[708].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_708] = unsafe { *(result.output.as_ptr() as *const [G; OUT_708]) }; __ret } else { aiur_fn_708(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_709] = []; + record.function_queries[709].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_710: usize = 1; +const IN_710: usize = 1; +const OUT_710: usize = 0; +fn aiur_fn_710( + inp: [G; IN_710], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_710], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + match __v_0.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_710] = []; + record.function_queries[710].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 __v_3: G = G::from_u64(0); + let __io_pair: (G, G) = { let __key: [G; 1] = [__v_2]; let __info = io_buffer.get_info(__v_3, &__key[..])?; (G::from_usize(__info.idx), G::from_usize(__info.len)) }; + let __v_4: G = __io_pair.0; + let __v_5: G = __io_pair.1; + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_0] = { let __args: [G; IN_0] = [__v_6, __v_4, __v_5]; let __cu = true; if let Some(result) = record.function_queries[0].get_mut(&__args[..]) { let __ret: [G; OUT_0] = unsafe { *(result.output.as_ptr() as *const [G; OUT_0]) }; __ret } else { aiur_fn_0(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __r_arr: [G; OUT_108] = { let __args: [G; IN_108] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[108].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_108] = unsafe { *(result.output.as_ptr() as *const [G; OUT_108]) }; __ret } else { aiur_fn_108(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_13: G = __r_arr[5]; + let __v_14: G = __r_arr[6]; + let __v_15: G = __r_arr[7]; + let __v_16: G = __r_arr[8]; + let __v_17: G = __r_arr[9]; + let __v_18: G = __r_arr[10]; + let __v_19: G = __r_arr[11]; + let __v_20: G = __r_arr[12]; + let __v_21: G = __r_arr[13]; + let __v_22: G = __r_arr[14]; + let __v_23: G = __r_arr[15]; + let __v_24: G = __r_arr[16]; + let __v_25: G = __r_arr[17]; + let __v_26: G = __r_arr[18]; + let __v_27: G = __r_arr[19]; + let __v_28: G = __r_arr[20]; + let __v_29: G = __r_arr[21]; + let __v_30: G = __r_arr[22]; + let __v_31: G = __r_arr[23]; + let __v_32: G = __r_arr[24]; + let __v_33: G = __r_arr[25]; + let __v_34: G = __r_arr[26]; + let __v_35: G = __r_arr[27]; + let __v_36: G = __r_arr[28]; + let __v_37: G = __r_arr[29]; + let __v_38: G = __r_arr[30]; + let __v_39: G = __r_arr[31]; + let __v_40: G = __r_arr[32]; + let __v_41: G = __r_arr[33]; + let __v_42: G = __r_arr[34]; + let __v_43: G = __r_arr[35]; + let __v_44: G = __r_arr[36]; + let __v_45: G = __r_arr[37]; + let __v_46: G = __r_arr[38]; + let __v_47: G = __r_arr[39]; + let __v_48: G = __r_arr[40]; + let __v_49: G = __r_arr[41]; + let __v_50: G = __r_arr[42]; + let __v_51: G = __r_arr[43]; + let __v_52: G = __r_arr[44]; + let __v_53: G = __r_arr[45]; + let __v_54: G = __r_arr[46]; + let __v_55: G = __r_arr[47]; + let __v_56: G = __r_arr[48]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_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: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_57: G = __loaded[0]; + let __v_58: G = __loaded[1]; + let __v_59: G = __loaded[2]; + let __v_60: G = G::from_u64(1); + let __v_61: G = G::from_u64(1); + if (__v_57 != __v_60) { + return Err(ExecError::AssertEqMismatch { lhs: __v_57.as_canonical_u64(), rhs: __v_60.as_canonical_u64() }); + } + if (__v_58 != __v_61) { + return Err(ExecError::AssertEqMismatch { lhs: __v_58.as_canonical_u64(), rhs: __v_61.as_canonical_u64() }); + } + if (__v_59 != __v_61) { + return Err(ExecError::AssertEqMismatch { lhs: __v_59.as_canonical_u64(), rhs: __v_61.as_canonical_u64() }); + } + let __v_62: G = G::from_u64(1); + let __v_63: G = G::from_u64(1); + let __v_64: G = { let __values: [G; 3] = [__v_62, __v_63, __v_63]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_70] = { let __args: [G; IN_70] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __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_64]; let __cu = unconstrained; if let Some(result) = record.function_queries[70].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_70] = unsafe { *(result.output.as_ptr() as *const [G; OUT_70]) }; __ret } else { aiur_fn_70(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __v_66: G = __r_arr[0]; + let __v_67: G = __r_arr[1]; + let __v_68: G = __r_arr[2]; + let __v_69: G = __r_arr[3]; + let __v_70: G = __r_arr[4]; + let __v_71: G = __r_arr[5]; + let __v_72: G = __r_arr[6]; + let __v_73: G = __r_arr[7]; + let __v_74: G = __r_arr[8]; + let __v_75: G = __r_arr[9]; + let __v_76: G = __r_arr[10]; + let __v_77: G = __r_arr[11]; + let __v_78: G = __r_arr[12]; + let __v_79: G = __r_arr[13]; + let __v_80: G = __r_arr[14]; + let __v_81: G = __r_arr[15]; + let __v_82: G = __r_arr[16]; + let __v_83: G = __r_arr[17]; + let __v_84: G = __r_arr[18]; + let __v_85: G = __r_arr[19]; + let __v_86: G = __r_arr[20]; + let __v_87: G = __r_arr[21]; + let __v_88: G = __r_arr[22]; + let __v_89: G = __r_arr[23]; + let __v_90: G = __r_arr[24]; + let __v_91: G = __r_arr[25]; + let __v_92: G = __r_arr[26]; + let __v_93: G = __r_arr[27]; + let __v_94: G = __r_arr[28]; + let __v_95: G = __r_arr[29]; + let __v_96: G = __r_arr[30]; + let __v_97: G = __r_arr[31]; + let __r_arr: [G; OUT_17] = { let __args: [G; IN_17] = [__v_65]; let __cu = unconstrained; if let Some(result) = record.function_queries[17].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_17] = unsafe { *(result.output.as_ptr() as *const [G; OUT_17]) }; __ret } else { aiur_fn_17(__args, record, io_buffer, __cu)? } }; + let __v_98: G = __r_arr[0]; + let __v_99: G = __r_arr[1]; + let __v_100: G = __r_arr[2]; + let __v_101: G = __r_arr[3]; + let __v_102: G = __r_arr[4]; + let __v_103: G = __r_arr[5]; + let __v_104: G = __r_arr[6]; + let __v_105: G = __r_arr[7]; + let __v_106: G = __r_arr[8]; + let __v_107: G = __r_arr[9]; + let __v_108: G = __r_arr[10]; + let __v_109: G = __r_arr[11]; + let __v_110: G = __r_arr[12]; + let __v_111: G = __r_arr[13]; + let __v_112: G = __r_arr[14]; + let __v_113: G = __r_arr[15]; + let __v_114: G = __r_arr[16]; + let __v_115: G = __r_arr[17]; + let __v_116: G = __r_arr[18]; + let __v_117: G = __r_arr[19]; + let __v_118: G = __r_arr[20]; + let __v_119: G = __r_arr[21]; + let __v_120: G = __r_arr[22]; + let __v_121: G = __r_arr[23]; + let __v_122: G = __r_arr[24]; + let __v_123: G = __r_arr[25]; + let __v_124: G = __r_arr[26]; + let __v_125: G = __r_arr[27]; + let __v_126: G = __r_arr[28]; + let __v_127: G = __r_arr[29]; + let __v_128: G = __r_arr[30]; + let __v_129: G = __r_arr[31]; + if (__v_66 != __v_98) { + return Err(ExecError::AssertEqMismatch { lhs: __v_66.as_canonical_u64(), rhs: __v_98.as_canonical_u64() }); + } + if (__v_67 != __v_99) { + return Err(ExecError::AssertEqMismatch { lhs: __v_67.as_canonical_u64(), rhs: __v_99.as_canonical_u64() }); + } + if (__v_68 != __v_100) { + return Err(ExecError::AssertEqMismatch { lhs: __v_68.as_canonical_u64(), rhs: __v_100.as_canonical_u64() }); + } + if (__v_69 != __v_101) { + return Err(ExecError::AssertEqMismatch { lhs: __v_69.as_canonical_u64(), rhs: __v_101.as_canonical_u64() }); + } + if (__v_70 != __v_102) { + return Err(ExecError::AssertEqMismatch { lhs: __v_70.as_canonical_u64(), rhs: __v_102.as_canonical_u64() }); + } + if (__v_71 != __v_103) { + return Err(ExecError::AssertEqMismatch { lhs: __v_71.as_canonical_u64(), rhs: __v_103.as_canonical_u64() }); + } + if (__v_72 != __v_104) { + return Err(ExecError::AssertEqMismatch { lhs: __v_72.as_canonical_u64(), rhs: __v_104.as_canonical_u64() }); + } + if (__v_73 != __v_105) { + return Err(ExecError::AssertEqMismatch { lhs: __v_73.as_canonical_u64(), rhs: __v_105.as_canonical_u64() }); + } + if (__v_74 != __v_106) { + return Err(ExecError::AssertEqMismatch { lhs: __v_74.as_canonical_u64(), rhs: __v_106.as_canonical_u64() }); + } + if (__v_75 != __v_107) { + return Err(ExecError::AssertEqMismatch { lhs: __v_75.as_canonical_u64(), rhs: __v_107.as_canonical_u64() }); + } + if (__v_76 != __v_108) { + return Err(ExecError::AssertEqMismatch { lhs: __v_76.as_canonical_u64(), rhs: __v_108.as_canonical_u64() }); + } + if (__v_77 != __v_109) { + return Err(ExecError::AssertEqMismatch { lhs: __v_77.as_canonical_u64(), rhs: __v_109.as_canonical_u64() }); + } + if (__v_78 != __v_110) { + return Err(ExecError::AssertEqMismatch { lhs: __v_78.as_canonical_u64(), rhs: __v_110.as_canonical_u64() }); + } + if (__v_79 != __v_111) { + return Err(ExecError::AssertEqMismatch { lhs: __v_79.as_canonical_u64(), rhs: __v_111.as_canonical_u64() }); + } + if (__v_80 != __v_112) { + return Err(ExecError::AssertEqMismatch { lhs: __v_80.as_canonical_u64(), rhs: __v_112.as_canonical_u64() }); + } + if (__v_81 != __v_113) { + return Err(ExecError::AssertEqMismatch { lhs: __v_81.as_canonical_u64(), rhs: __v_113.as_canonical_u64() }); + } + if (__v_82 != __v_114) { + return Err(ExecError::AssertEqMismatch { lhs: __v_82.as_canonical_u64(), rhs: __v_114.as_canonical_u64() }); + } + if (__v_83 != __v_115) { + return Err(ExecError::AssertEqMismatch { lhs: __v_83.as_canonical_u64(), rhs: __v_115.as_canonical_u64() }); + } + if (__v_84 != __v_116) { + return Err(ExecError::AssertEqMismatch { lhs: __v_84.as_canonical_u64(), rhs: __v_116.as_canonical_u64() }); + } + if (__v_85 != __v_117) { + return Err(ExecError::AssertEqMismatch { lhs: __v_85.as_canonical_u64(), rhs: __v_117.as_canonical_u64() }); + } + if (__v_86 != __v_118) { + return Err(ExecError::AssertEqMismatch { lhs: __v_86.as_canonical_u64(), rhs: __v_118.as_canonical_u64() }); + } + if (__v_87 != __v_119) { + return Err(ExecError::AssertEqMismatch { lhs: __v_87.as_canonical_u64(), rhs: __v_119.as_canonical_u64() }); + } + if (__v_88 != __v_120) { + return Err(ExecError::AssertEqMismatch { lhs: __v_88.as_canonical_u64(), rhs: __v_120.as_canonical_u64() }); + } + if (__v_89 != __v_121) { + return Err(ExecError::AssertEqMismatch { lhs: __v_89.as_canonical_u64(), rhs: __v_121.as_canonical_u64() }); + } + if (__v_90 != __v_122) { + return Err(ExecError::AssertEqMismatch { lhs: __v_90.as_canonical_u64(), rhs: __v_122.as_canonical_u64() }); + } + if (__v_91 != __v_123) { + return Err(ExecError::AssertEqMismatch { lhs: __v_91.as_canonical_u64(), rhs: __v_123.as_canonical_u64() }); + } + if (__v_92 != __v_124) { + return Err(ExecError::AssertEqMismatch { lhs: __v_92.as_canonical_u64(), rhs: __v_124.as_canonical_u64() }); + } + if (__v_93 != __v_125) { + return Err(ExecError::AssertEqMismatch { lhs: __v_93.as_canonical_u64(), rhs: __v_125.as_canonical_u64() }); + } + if (__v_94 != __v_126) { + return Err(ExecError::AssertEqMismatch { lhs: __v_94.as_canonical_u64(), rhs: __v_126.as_canonical_u64() }); + } + if (__v_95 != __v_127) { + return Err(ExecError::AssertEqMismatch { lhs: __v_95.as_canonical_u64(), rhs: __v_127.as_canonical_u64() }); + } + if (__v_96 != __v_128) { + return Err(ExecError::AssertEqMismatch { lhs: __v_96.as_canonical_u64(), rhs: __v_128.as_canonical_u64() }); + } + if (__v_97 != __v_129) { + return Err(ExecError::AssertEqMismatch { lhs: __v_97.as_canonical_u64(), rhs: __v_129.as_canonical_u64() }); + } + let __r_arr: [G; OUT_710] = { let __args: [G; IN_710] = [__v_2]; let __cu = unconstrained; if let Some(result) = record.function_queries[710].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_710] = unsafe { *(result.output.as_ptr() as *const [G; OUT_710]) }; __ret } else { aiur_fn_710(__args, record, io_buffer, __cu)? } }; + let __ret: [G; OUT_710] = []; + record.function_queries[710].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], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_711], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(1); + let __v_7: G = G::from_u64(1); + let __v_8: G = { let __values: [G; 3] = [__v_6, __v_7, __v_7]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_9: G = { let __values: [G; 3] = [__v_5, __v_1, __v_8]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_711] = [__v_9]; + record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_711] = { let __args: [G; IN_711] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[711].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_711] = unsafe { *(result.output.as_ptr() as *const [G; OUT_711]) }; __ret } else { aiur_fn_711(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = { let __values: [G; 3] = [__v_5, __v_3, __v_6]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_711] = [__v_7]; + record.function_queries[711].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_712: usize = 1; +const IN_712: usize = 1; +const OUT_712: usize = 8; +fn aiur_fn_712( + inp: [G; IN_712], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_712], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __ret: [G; OUT_712] = [__v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_712] = { let __args: [G; IN_712] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[712].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_712] = unsafe { *(result.output.as_ptr() as *const [G; OUT_712]) }; __ret } else { aiur_fn_712(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = __r_arr[1]; + let __v_13: G = __r_arr[2]; + 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 __r_arr: [G; OUT_10] = { let __args: [G; IN_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[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_712] = [__v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26]; + record.function_queries[712].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_713: usize = 1; +const IN_713: usize = 1; +const OUT_713: usize = 8; +fn aiur_fn_713( + inp: [G; IN_713], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_713], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + 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 __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(0); + let __v_7: G = G::from_u64(0); + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(0); + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_713] = [__v_4, __v_5, __v_6, __v_7, __v_8, __v_9, __v_10, __v_11]; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_713] = { let __args: [G; IN_713] = [__v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[713].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_713] = unsafe { *(result.output.as_ptr() as *const [G; OUT_713]) }; __ret } else { aiur_fn_713(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __v_5: G = __r_arr[1]; + let __v_6: G = __r_arr[2]; + let __v_7: G = __r_arr[3]; + let __v_8: G = __r_arr[4]; + let __v_9: G = __r_arr[5]; + let __v_10: G = __r_arr[6]; + let __v_11: G = __r_arr[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_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 __ret: [G; OUT_713] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[713].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_714: usize = 2; +const IN_714: usize = 2; +const OUT_714: usize = 1; +fn aiur_fn_714( + inp: [G; IN_714], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_714], 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_714] = [__v_1]; + record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_5: G = G::from_u64(0); + let __r_arr: [G; OUT_714] = { let __args: [G; IN_714] = [__v_4, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[714].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_714] = unsafe { *(result.output.as_ptr() as *const [G; OUT_714]) }; __ret } else { aiur_fn_714(__args, record, io_buffer, __cu)? } }; + let __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_714] = [__v_7]; + record.function_queries[714].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_715: usize = 8; +const IN_715: usize = 8; +const OUT_715: usize = 1; +fn aiur_fn_715( + inp: [G; IN_715], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_715], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_715] = [__v_7]; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_5.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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]; + 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_14: G = __loaded[0]; + let __v_15: G = __loaded[1]; + let __v_16: G = __loaded[2]; + let __v_17: G = __loaded[3]; + let __v_18: G = __loaded[4]; + let __v_19: G = __loaded[5]; + let __v_20: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_20.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_8, __v_9, __v_10, __v_11, __v_12, __v_13, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_715] = [__v_21]; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_21: G = (__v_0 - __v_3); + match __v_21.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_715] = [__v_4]; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_715] = { let __args: [G; IN_715] = [__v_0, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[715].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_715] = unsafe { *(result.output.as_ptr() as *const [G; OUT_715]) }; __ret } else { aiur_fn_715(__args, record, io_buffer, __cu)? } }; + let __v_22: G = __r_arr[0]; + let __ret: [G; OUT_715] = [__v_22]; + record.function_queries[715].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_716: usize = 1; +const IN_716: usize = 1; +const OUT_716: usize = 1; +fn aiur_fn_716( + inp: [G; IN_716], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_716], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = G::from_u64(1); + let __v_2: G = G::from_u64(1); + let __v_3: G = { let __values: [G; 3] = [__v_1, __v_2, __v_2]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __r_arr: [G; OUT_738] = { let __args: [G; IN_738] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __ret: [G; OUT_716] = [__v_4]; + record.function_queries[716].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }) +} + +const INPUT_SIZE_717: usize = 1; +const IN_717: usize = 1; +const OUT_717: usize = 8; +fn aiur_fn_717( + inp: [G; IN_717], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_717], 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_37: G = G::from_u64(0); + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(0); + let __v_42: G = G::from_u64(0); + let __v_43: G = G::from_u64(0); + let __v_44: G = G::from_u64(0); + let __ret: [G; OUT_717] = [__v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44]; + record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_717] = { let __args: [G; IN_717] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[717].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_717] = unsafe { *(result.output.as_ptr() as *const [G; OUT_717]) }; __ret } else { aiur_fn_717(__args, record, io_buffer, __cu)? } }; + let __v_37: G = __r_arr[0]; + let __v_38: G = __r_arr[1]; + let __v_39: G = __r_arr[2]; + let __v_40: G = __r_arr[3]; + let __v_41: G = __r_arr[4]; + let __v_42: G = __r_arr[5]; + let __v_43: G = __r_arr[6]; + let __v_44: G = __r_arr[7]; + let __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + let __v_46: G = __r_arr[1]; + let __v_47: G = __r_arr[2]; + let __v_48: G = __r_arr[3]; + let __v_49: G = __r_arr[4]; + let __v_50: G = __r_arr[5]; + let __v_51: G = __r_arr[6]; + let __v_52: G = __r_arr[7]; + let __ret: [G; OUT_717] = [__v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52]; + record.function_queries[717].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_718: usize = 2; +const IN_718: usize = 2; +const OUT_718: usize = 1; +fn aiur_fn_718( + inp: [G; IN_718], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_718], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __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]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_718] = [__v_4]; + record.function_queries[718].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_719: usize = 1; +const IN_719: usize = 1; +const OUT_719: usize = 1; +fn aiur_fn_719( + inp: [G; IN_719], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_719], 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 }; + 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_719] = [__v_7]; + record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_719] = { let __args: [G; IN_719] = [__v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[719].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_719] = unsafe { *(result.output.as_ptr() as *const [G; OUT_719]) }; __ret } else { aiur_fn_719(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __v_8: G = G::from_u64(1); + let __v_9: G = (__v_7 + __v_8); + let __ret: [G; OUT_719] = [__v_9]; + record.function_queries[719].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_720: usize = 9; +const IN_720: usize = 9; +const OUT_720: usize = 1; +fn aiur_fn_720( + inp: [G; IN_720], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_720], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(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_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__v_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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; 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 __ret: [G; OUT_720] = [__v_10]; + record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_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 __r_arr: [G; OUT_720] = { let __args: [G; IN_720] = [__v_11, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; let __cu = unconstrained; if let Some(result) = record.function_queries[720].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_720] = unsafe { *(result.output.as_ptr() as *const [G; OUT_720]) }; __ret } else { aiur_fn_720(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_720] = [__v_21]; + record.function_queries[720].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_12.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_721: usize = 1; +const IN_721: usize = 1; +const OUT_721: usize = 1; +fn aiur_fn_721( + inp: [G; IN_721], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_721], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 10 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 10] = __args[..10].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_11: G = G::from_u64(0); + let __ret: [G; OUT_721] = [__v_11]; + record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_721] = { let __args: [G; IN_721] = [__v_10]; let __cu = unconstrained; if let Some(result) = record.function_queries[721].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_721] = unsafe { *(result.output.as_ptr() as *const [G; OUT_721]) }; __ret } else { aiur_fn_721(__args, record, io_buffer, __cu)? } }; + let __v_11: G = __r_arr[0]; + let __v_12: G = G::from_u64(1); + let __v_13: G = (__v_11 + __v_12); + let __ret: [G; OUT_721] = [__v_13]; + record.function_queries[721].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_722: usize = 7; +const IN_722: usize = 7; +const OUT_722: usize = 1; +fn aiur_fn_722( + inp: [G; IN_722], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_722], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_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: 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]; + 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_13: G = __loaded[0]; + let __v_14: G = __loaded[1]; + let __v_15: G = __loaded[2]; + let __v_16: G = __loaded[3]; + let __v_17: G = __loaded[4]; + let __v_18: G = __loaded[5]; + let __v_19: G = { let __a_val = __v_0.as_canonical_u64(); let __b_val = __v_3.as_canonical_u64(); let __a_u32 = u32::try_from(__a_val).ok().ok_or(ExecError::U32OutOfRange(__a_val))?; let __b_u32 = u32::try_from(__b_val).ok().ok_or(ExecError::U32OutOfRange(__b_val))?; let __result = G::from_bool(__a_u32 < __b_u32); if !unconstrained { let __x_bytes = __a_u32.to_le_bytes(); let __z_bytes = __b_u32.to_le_bytes(); let __c_u32 = __b_u32.wrapping_sub(__a_u32).wrapping_sub(1); let __y_bytes = __c_u32.to_le_bytes(); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[0]), &G::from_u8(__x_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__x_bytes[2]), &G::from_u8(__x_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[0]), &G::from_u8(__y_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__y_bytes[2]), &G::from_u8(__y_bytes[3])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[0]), &G::from_u8(__z_bytes[1])); record.bytes2_queries.bump_range_check(&G::from_u8(__z_bytes[2]), &G::from_u8(__z_bytes[3])); } __result }; + match __v_19.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_7, __v_8, __v_9, __v_10, __v_11, __v_12]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_20: G = __r_arr[0]; + let __ret: [G; OUT_722] = [__v_20]; + record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_20: G = (__v_0 - __v_3); + match __v_20.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_722] = [__v_4]; + record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_722] = { let __args: [G; IN_722] = [__v_0, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18]; let __cu = unconstrained; if let Some(result) = record.function_queries[722].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_722] = unsafe { *(result.output.as_ptr() as *const [G; OUT_722]) }; __ret } else { aiur_fn_722(__args, record, io_buffer, __cu)? } }; + let __v_21: G = __r_arr[0]; + let __ret: [G; OUT_722] = [__v_21]; + record.function_queries[722].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_723: usize = 9; +const IN_723: usize = 9; +const OUT_723: usize = 45; +fn aiur_fn_723( + inp: [G; IN_723], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_723], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __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 }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __v_20: G = __loaded[11]; + let __v_21: G = __loaded[12]; + let __v_22: G = __loaded[13]; + let __v_23: G = __loaded[14]; + let __v_24: G = __loaded[15]; + let __v_25: G = __loaded[16]; + let __v_26: G = __loaded[17]; + let __v_27: G = __loaded[18]; + let __v_28: G = __loaded[19]; + let __v_29: G = __loaded[20]; + let __v_30: G = __loaded[21]; + let __v_31: G = __loaded[22]; + let __v_32: G = __loaded[23]; + let __v_33: G = __loaded[24]; + let __v_34: G = __loaded[25]; + let __v_35: G = __loaded[26]; + let __v_36: G = __loaded[27]; + let __v_37: G = __loaded[28]; + let __v_38: G = __loaded[29]; + let __v_39: G = __loaded[30]; + let __v_40: G = __loaded[31]; + let __v_41: G = __loaded[32]; + let __v_42: G = __loaded[33]; + let __v_43: G = __loaded[34]; + let __v_44: G = __loaded[35]; + let __v_45: G = __loaded[36]; + let __v_46: G = __loaded[37]; + let __v_47: G = __loaded[38]; + let __v_48: G = __loaded[39]; + let __v_49: G = __loaded[40]; + let __v_50: G = __loaded[41]; + let __v_51: G = __loaded[42]; + let __v_52: G = __loaded[43]; + let __v_53: G = __loaded[44]; + let __v_54: G = __loaded[45]; + let __v_55: G = __loaded[46]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + match __v_56.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_723] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43, __v_44, __v_45, __v_46, __v_47, __v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54]; + record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_57: G = __r_arr[0]; + let __v_58: G = __r_arr[1]; + let __v_59: G = __r_arr[2]; + let __v_60: G = __r_arr[3]; + let __v_61: G = __r_arr[4]; + let __v_62: G = __r_arr[5]; + let __v_63: G = __r_arr[6]; + let __v_64: G = __r_arr[7]; + let __r_arr: [G; OUT_723] = { let __args: [G; IN_723] = [__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[723].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_723] = unsafe { *(result.output.as_ptr() as *const [G; OUT_723]) }; __ret } else { aiur_fn_723(__args, record, io_buffer, __cu)? } }; + let __v_65: G = __r_arr[0]; + let __v_66: G = __r_arr[1]; + let __v_67: G = __r_arr[2]; + let __v_68: G = __r_arr[3]; + let __v_69: G = __r_arr[4]; + let __v_70: G = __r_arr[5]; + let __v_71: G = __r_arr[6]; + let __v_72: G = __r_arr[7]; + let __v_73: G = __r_arr[8]; + let __v_74: G = __r_arr[9]; + let __v_75: G = __r_arr[10]; + let __v_76: G = __r_arr[11]; + let __v_77: G = __r_arr[12]; + let __v_78: G = __r_arr[13]; + let __v_79: G = __r_arr[14]; + let __v_80: G = __r_arr[15]; + let __v_81: G = __r_arr[16]; + let __v_82: G = __r_arr[17]; + let __v_83: G = __r_arr[18]; + let __v_84: G = __r_arr[19]; + let __v_85: G = __r_arr[20]; + let __v_86: G = __r_arr[21]; + let __v_87: G = __r_arr[22]; + let __v_88: G = __r_arr[23]; + let __v_89: G = __r_arr[24]; + let __v_90: G = __r_arr[25]; + let __v_91: G = __r_arr[26]; + let __v_92: G = __r_arr[27]; + let __v_93: G = __r_arr[28]; + let __v_94: G = __r_arr[29]; + let __v_95: G = __r_arr[30]; + let __v_96: G = __r_arr[31]; + let __v_97: G = __r_arr[32]; + let __v_98: G = __r_arr[33]; + let __v_99: G = __r_arr[34]; + let __v_100: G = __r_arr[35]; + let __v_101: G = __r_arr[36]; + let __v_102: G = __r_arr[37]; + let __v_103: G = __r_arr[38]; + let __v_104: G = __r_arr[39]; + let __v_105: G = __r_arr[40]; + let __v_106: G = __r_arr[41]; + 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_723] = [__v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87, __v_88, __v_89, __v_90, __v_91, __v_92, __v_93, __v_94, __v_95, __v_96, __v_97, __v_98, __v_99, __v_100, __v_101, __v_102, __v_103, __v_104, __v_105, __v_106, __v_107, __v_108, __v_109]; + record.function_queries[723].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_56.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_724: usize = 2; +const IN_724: usize = 2; +const OUT_724: usize = 1; +fn aiur_fn_724( + inp: [G; IN_724], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_724], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + let __v_6: G = __loaded[4]; + let __v_7: G = __loaded[5]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_724] = [__v_1]; + record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_8: G = G::from_u64(0); + let __r_arr: [G; OUT_724] = { let __args: [G; IN_724] = [__v_7, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[724].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_724] = unsafe { *(result.output.as_ptr() as *const [G; OUT_724]) }; __ret } else { aiur_fn_724(__args, record, io_buffer, __cu)? } }; + let __v_9: G = __r_arr[0]; + let __v_10: G = { let __values: [G; 6] = [__v_8, __v_3, __v_4, __v_5, __v_6, __v_9]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_724] = [__v_10]; + record.function_queries[724].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_725: usize = 1; +const IN_725: usize = 1; +const OUT_725: usize = 8; +fn aiur_fn_725( + inp: [G; IN_725], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_725], 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + let __v_37: G = __loaded[36]; + let __v_38: G = __loaded[37]; + let __v_39: G = __loaded[38]; + let __v_40: G = __loaded[39]; + let __v_41: G = __loaded[40]; + let __v_42: G = __loaded[41]; + let __v_43: G = __loaded[42]; + let __v_44: G = __loaded[43]; + let __v_45: G = __loaded[44]; + let __v_46: G = __loaded[45]; + let __v_47: G = __loaded[46]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_48: G = G::from_u64(0); + let __v_49: G = G::from_u64(0); + let __v_50: G = G::from_u64(0); + let __v_51: G = G::from_u64(0); + let __v_52: G = G::from_u64(0); + let __v_53: G = G::from_u64(0); + let __v_54: G = G::from_u64(0); + let __v_55: G = G::from_u64(0); + let __ret: [G; OUT_725] = [__v_48, __v_49, __v_50, __v_51, __v_52, __v_53, __v_54, __v_55]; + record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_725] = { let __args: [G; IN_725] = [__v_47]; let __cu = unconstrained; if let Some(result) = record.function_queries[725].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_725] = unsafe { *(result.output.as_ptr() as *const [G; OUT_725]) }; __ret } else { aiur_fn_725(__args, record, io_buffer, __cu)? } }; + let __v_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 __r_arr: [G; OUT_10] = { let __args: [G; IN_10] = [__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[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_56: G = __r_arr[0]; + let __v_57: G = __r_arr[1]; + let __v_58: G = __r_arr[2]; + let __v_59: G = __r_arr[3]; + let __v_60: G = __r_arr[4]; + 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_725] = [__v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63]; + record.function_queries[725].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_726: usize = 1; +const IN_726: usize = 1; +const OUT_726: usize = 8; +fn aiur_fn_726( + inp: [G; IN_726], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_726], 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_12: G = G::from_u64(0); + let __v_13: G = G::from_u64(0); + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(0); + let __v_16: G = G::from_u64(0); + let __v_17: G = G::from_u64(0); + let __v_18: G = G::from_u64(0); + let __v_19: G = G::from_u64(0); + let __ret: [G; OUT_726] = [__v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; + record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_726] = { let __args: [G; IN_726] = [__v_11]; let __cu = unconstrained; if let Some(result) = record.function_queries[726].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_726] = unsafe { *(result.output.as_ptr() as *const [G; OUT_726]) }; __ret } else { aiur_fn_726(__args, record, io_buffer, __cu)? } }; + let __v_12: G = __r_arr[0]; + let __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_10] = { let __args: [G; IN_10] = [__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[10].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_10] = unsafe { *(result.output.as_ptr() as *const [G; OUT_10]) }; __ret } else { aiur_fn_10(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_24: G = __r_arr[4]; + 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_726] = [__v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27]; + record.function_queries[726].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_727: usize = 2; +const IN_727: usize = 2; +const OUT_727: usize = 1; +fn aiur_fn_727( + inp: [G; IN_727], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_727], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __loaded: [G; 4] = { let __mq = record.memory_queries.get_mut(&4).ok_or(ExecError::InvalidMemorySize(4))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 4 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 4] = __args[..4].try_into().unwrap(); __arr }; + let __v_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + let __v_5: G = __loaded[3]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_727] = [__v_1]; + record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_6: G = G::from_u64(0); + let __r_arr: [G; OUT_727] = { let __args: [G; IN_727] = [__v_5, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[727].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_727] = unsafe { *(result.output.as_ptr() as *const [G; OUT_727]) }; __ret } else { aiur_fn_727(__args, record, io_buffer, __cu)? } }; + let __v_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_727] = [__v_8]; + record.function_queries[727].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_728: usize = 9; +const IN_728: usize = 9; +const OUT_728: usize = 34; +fn aiur_fn_728( + inp: [G; IN_728], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_728], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 36] = { let __mq = record.memory_queries.get_mut(&36).ok_or(ExecError::InvalidMemorySize(36))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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 }; + let __v_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + let __v_19: G = __loaded[10]; + let __v_20: G = __loaded[11]; + let __v_21: G = __loaded[12]; + let __v_22: G = __loaded[13]; + let __v_23: G = __loaded[14]; + let __v_24: G = __loaded[15]; + let __v_25: G = __loaded[16]; + let __v_26: G = __loaded[17]; + let __v_27: G = __loaded[18]; + let __v_28: G = __loaded[19]; + let __v_29: G = __loaded[20]; + let __v_30: G = __loaded[21]; + let __v_31: G = __loaded[22]; + let __v_32: G = __loaded[23]; + let __v_33: G = __loaded[24]; + let __v_34: G = __loaded[25]; + let __v_35: G = __loaded[26]; + let __v_36: G = __loaded[27]; + let __v_37: G = __loaded[28]; + let __v_38: G = __loaded[29]; + let __v_39: G = __loaded[30]; + let __v_40: G = __loaded[31]; + let __v_41: G = __loaded[32]; + let __v_42: G = __loaded[33]; + let __v_43: G = __loaded[34]; + let __v_44: G = __loaded[35]; + match __v_9.as_canonical_u64() { + 0u64 => { + let __r_arr: [G; OUT_2] = { let __args: [G; IN_2] = [__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[2].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_2] = unsafe { *(result.output.as_ptr() as *const [G; OUT_2]) }; __ret } else { aiur_fn_2(__args, record, io_buffer, __cu)? } }; + let __v_45: G = __r_arr[0]; + match __v_45.as_canonical_u64() { + 1u64 => { + let __ret: [G; OUT_728] = [__v_10, __v_11, __v_12, __v_13, __v_14, __v_15, __v_16, __v_17, __v_18, __v_19, __v_20, __v_21, __v_22, __v_23, __v_24, __v_25, __v_26, __v_27, __v_28, __v_29, __v_30, __v_31, __v_32, __v_33, __v_34, __v_35, __v_36, __v_37, __v_38, __v_39, __v_40, __v_41, __v_42, __v_43]; + record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_13] = { let __args: [G; IN_13] = [__v_1, __v_2, __v_3, __v_4, __v_5, __v_6, __v_7, __v_8]; let __cu = unconstrained; if let Some(result) = record.function_queries[13].get_mut(&__args[..]) { 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_46: G = __r_arr[0]; + let __v_47: G = __r_arr[1]; + let __v_48: G = __r_arr[2]; + let __v_49: G = __r_arr[3]; + let __v_50: G = __r_arr[4]; + let __v_51: G = __r_arr[5]; + let __v_52: G = __r_arr[6]; + let __v_53: G = __r_arr[7]; + let __r_arr: [G; OUT_728] = { let __args: [G; IN_728] = [__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[728].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_728] = unsafe { *(result.output.as_ptr() as *const [G; OUT_728]) }; __ret } else { aiur_fn_728(__args, record, io_buffer, __cu)? } }; + let __v_54: G = __r_arr[0]; + let __v_55: G = __r_arr[1]; + let __v_56: G = __r_arr[2]; + let __v_57: G = __r_arr[3]; + let __v_58: G = __r_arr[4]; + let __v_59: G = __r_arr[5]; + let __v_60: G = __r_arr[6]; + let __v_61: G = __r_arr[7]; + let __v_62: G = __r_arr[8]; + let __v_63: G = __r_arr[9]; + let __v_64: G = __r_arr[10]; + let __v_65: G = __r_arr[11]; + let __v_66: G = __r_arr[12]; + let __v_67: G = __r_arr[13]; + let __v_68: G = __r_arr[14]; + let __v_69: G = __r_arr[15]; + let __v_70: G = __r_arr[16]; + let __v_71: G = __r_arr[17]; + let __v_72: G = __r_arr[18]; + let __v_73: G = __r_arr[19]; + let __v_74: G = __r_arr[20]; + let __v_75: G = __r_arr[21]; + let __v_76: G = __r_arr[22]; + let __v_77: G = __r_arr[23]; + let __v_78: G = __r_arr[24]; + let __v_79: G = __r_arr[25]; + let __v_80: G = __r_arr[26]; + let __v_81: G = __r_arr[27]; + let __v_82: G = __r_arr[28]; + let __v_83: G = __r_arr[29]; + let __v_84: G = __r_arr[30]; + let __v_85: G = __r_arr[31]; + let __v_86: G = __r_arr[32]; + let __v_87: G = __r_arr[33]; + let __ret: [G; OUT_728] = [__v_54, __v_55, __v_56, __v_57, __v_58, __v_59, __v_60, __v_61, __v_62, __v_63, __v_64, __v_65, __v_66, __v_67, __v_68, __v_69, __v_70, __v_71, __v_72, __v_73, __v_74, __v_75, __v_76, __v_77, __v_78, __v_79, __v_80, __v_81, __v_82, __v_83, __v_84, __v_85, __v_86, __v_87]; + record.function_queries[728].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_45.as_canonical_u64())); + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_729: usize = 1; +const IN_729: usize = 1; +const OUT_729: usize = 1; +fn aiur_fn_729( + inp: [G; IN_729], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_729], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __loaded: [G; 3] = { let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 3 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 3] = __args[..3].try_into().unwrap(); __arr }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_4: G = G::from_u64(1); + let __ret: [G; OUT_729] = [__v_4]; + record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_4: G = G::from_u64(0); + let __ret: [G; OUT_729] = [__v_4]; + record.function_queries[729].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_730: usize = 2; +const IN_730: usize = 2; +const OUT_730: usize = 3; +fn aiur_fn_730( + inp: [G; IN_730], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + let __r_arr: [G; OUT_739] = { let __args: [G; IN_739] = [__v_0, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __v_2: G = __r_arr[0]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_2.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_3: G = __loaded[0]; + let __v_4: G = __loaded[1]; + let __v_5: G = __loaded[2]; + let __v_6: G = __loaded[3]; + let __v_7: G = __loaded[4]; + match __v_3.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_730] = [__v_4, __v_5, __v_6]; + record.function_queries[730].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_3.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_731: usize = 2; +const IN_731: usize = 2; +const OUT_731: usize = 1; +fn aiur_fn_731( + inp: [G; IN_731], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_731], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __v_2: G = G::from_u64(1); + let __v_3: G = G::from_u64(1); + let __v_4: G = { let __values: [G; 3] = [__v_2, __v_3, __v_3]; let __mq = record.memory_queries.get_mut(&3).ok_or(ExecError::InvalidMemorySize(3))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_731] = [__v_4]; + record.function_queries[731].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_2: G = __loaded[0]; + let __v_3: G = __loaded[1]; + let __v_4: G = __loaded[2]; + match __v_2.as_canonical_u64() { + 0u64 => { + let __v_5: G = G::from_u64(0); + let __v_6: G = G::from_u64(1); + let __v_7: G = (__v_1 - __v_6); + let __r_arr: [G; OUT_731] = { let __args: [G; IN_731] = [__v_4, __v_7]; let __cu = unconstrained; if let Some(result) = record.function_queries[731].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_731] = unsafe { *(result.output.as_ptr() as *const [G; OUT_731]) }; __ret } else { aiur_fn_731(__args, record, io_buffer, __cu)? } }; + let __v_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_731] = [__v_9]; + record.function_queries[731].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }, + } + }) +} + +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_732], 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 }; + let __v_1: G = __loaded[0]; + let __v_2: G = __loaded[1]; + let __v_3: G = __loaded[2]; + let __v_4: G = __loaded[3]; + let __v_5: G = __loaded[4]; + let __v_6: G = __loaded[5]; + let __v_7: G = __loaded[6]; + let __v_8: G = __loaded[7]; + let __v_9: G = __loaded[8]; + let __v_10: G = __loaded[9]; + let __v_11: G = __loaded[10]; + let __v_12: G = __loaded[11]; + let __v_13: G = __loaded[12]; + let __v_14: G = __loaded[13]; + let __v_15: G = __loaded[14]; + let __v_16: G = __loaded[15]; + let __v_17: G = __loaded[16]; + let __v_18: G = __loaded[17]; + let __v_19: G = __loaded[18]; + let __v_20: G = __loaded[19]; + let __v_21: G = __loaded[20]; + let __v_22: G = __loaded[21]; + let __v_23: G = __loaded[22]; + let __v_24: G = __loaded[23]; + let __v_25: G = __loaded[24]; + let __v_26: G = __loaded[25]; + let __v_27: G = __loaded[26]; + let __v_28: G = __loaded[27]; + let __v_29: G = __loaded[28]; + let __v_30: G = __loaded[29]; + let __v_31: G = __loaded[30]; + let __v_32: G = __loaded[31]; + let __v_33: G = __loaded[32]; + let __v_34: G = __loaded[33]; + let __v_35: G = __loaded[34]; + let __v_36: G = __loaded[35]; + match __v_1.as_canonical_u64() { + 1u64 => { + let __v_37: G = G::from_u64(0); + let __ret: [G; OUT_732] = [__v_37]; + record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_732] = { let __args: [G; IN_732] = [__v_36]; let __cu = unconstrained; if let Some(result) = record.function_queries[732].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_732] = unsafe { *(result.output.as_ptr() as *const [G; OUT_732]) }; __ret } else { aiur_fn_732(__args, record, io_buffer, __cu)? } }; + let __v_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_732] = [__v_39]; + record.function_queries[732].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_733: usize = 2; +const IN_733: usize = 2; +const OUT_733: usize = 1; +fn aiur_fn_733( + inp: [G; IN_733], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_733], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + match __v_1.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_733] = [__v_0]; + record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_2: G = G::from_u64(1); + let __v_3: G = (__v_1 - __v_2); + let __r_arr: [G; OUT_733] = { let __args: [G; IN_733] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[733].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_733] = unsafe { *(result.output.as_ptr() as *const [G; OUT_733]) }; __ret } else { aiur_fn_733(__args, record, io_buffer, __cu)? } }; + let __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_733] = [__v_7]; + record.function_queries[733].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_734: usize = 1; +const IN_734: usize = 1; +const OUT_734: usize = 1; +fn aiur_fn_734( + inp: [G; IN_734], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_734], 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_734] = [__v_6]; + record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __r_arr: [G; OUT_734] = { let __args: [G; IN_734] = [__v_5]; let __cu = unconstrained; if let Some(result) = record.function_queries[734].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_734] = unsafe { *(result.output.as_ptr() as *const [G; OUT_734]) }; __ret } else { aiur_fn_734(__args, record, io_buffer, __cu)? } }; + let __v_6: G = __r_arr[0]; + let __v_7: G = G::from_u64(1); + let __v_8: G = (__v_6 + __v_7); + let __ret: [G; OUT_734] = [__v_8]; + record.function_queries[734].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_1.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_735: usize = 8; +const IN_735: usize = 8; +const OUT_735: usize = 6; +fn aiur_fn_735( + inp: [G; IN_735], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_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]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__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[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __v_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 __v_13: G = __r_arr[5]; + match __v_8.as_canonical_u64() { + 0u64 => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __ret: [G; OUT_735] = [__v_14, __v_15, __v_10, __v_11, __v_12, __v_13]; + record.function_queries[735].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_8.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_736: usize = 2; +const IN_736: usize = 2; +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_736], 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 __ret: [G; OUT_736] = [__v_1]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_7: G = G::from_u64(0); + let __r_arr: [G; OUT_736] = { let __args: [G; IN_736] = [__v_6, __v_1]; let __cu = unconstrained; if let Some(result) = record.function_queries[736].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_736] = unsafe { *(result.output.as_ptr() as *const [G; OUT_736]) }; __ret } else { aiur_fn_736(__args, record, io_buffer, __cu)? } }; + let __v_8: G = __r_arr[0]; + let __v_9: G = { let __values: [G; 5] = [__v_7, __v_3, __v_4, __v_5, __v_8]; let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_736] = [__v_9]; + record.function_queries[736].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_737: usize = 9; +const IN_737: usize = 9; +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_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]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + let __v_8: G = inp[8]; + let __loaded: [G; 10] = { let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; let __ptr_u64 = __v_0.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_9: G = __loaded[0]; + let __v_10: G = __loaded[1]; + let __v_11: G = __loaded[2]; + let __v_12: G = __loaded[3]; + let __v_13: G = __loaded[4]; + let __v_14: G = __loaded[5]; + let __v_15: G = __loaded[6]; + let __v_16: G = __loaded[7]; + let __v_17: G = __loaded[8]; + let __v_18: G = __loaded[9]; + match __v_9.as_canonical_u64() { + 1u64 => { + let __v_19: G = G::from_u64(0); + let __v_20: G = G::from_u64(1); + let __v_21: G = G::from_u64(1); + let __v_22: G = { let __values: [G; 10] = [__v_20, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21, __v_21]; let __mq = record.memory_queries.get_mut(&10).ok_or(ExecError::InvalidMemorySize(10))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_737] = [__v_23]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + 0u64 => { + let __v_19: G = G::from_u64(0); + let __r_arr: [G; OUT_737] = { let __args: [G; IN_737] = [__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[737].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_737] = unsafe { *(result.output.as_ptr() as *const [G; OUT_737]) }; __ret } else { aiur_fn_737(__args, record, io_buffer, __cu)? } }; + let __v_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_737] = [__v_21]; + record.function_queries[737].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_9.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_738: usize = 2; +const IN_738: usize = 2; +const OUT_738: usize = 1; +fn aiur_fn_738( + inp: [G; IN_738], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_738], 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_738] = [__v_1]; + record.function_queries[738].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_738] = { let __args: [G; IN_738] = [__v_4, __v_6]; let __cu = unconstrained; if let Some(result) = record.function_queries[738].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_738] = unsafe { *(result.output.as_ptr() as *const [G; OUT_738]) }; __ret } else { aiur_fn_738(__args, record, io_buffer, __cu)? } }; + let __v_7: G = __r_arr[0]; + let __ret: [G; OUT_738] = [__v_7]; + record.function_queries[738].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_739: usize = 2; +const IN_739: usize = 2; +const OUT_739: usize = 1; +fn aiur_fn_739( + inp: [G; IN_739], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_739], 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_739] = [__v_0]; + record.function_queries[739].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_739] = { let __args: [G; IN_739] = [__v_0, __v_3]; let __cu = unconstrained; if let Some(result) = record.function_queries[739].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_739] = unsafe { *(result.output.as_ptr() as *const [G; OUT_739]) }; __ret } else { aiur_fn_739(__args, record, io_buffer, __cu)? } }; + let __v_4: G = __r_arr[0]; + let __loaded: [G; 5] = { let __mq = record.memory_queries.get_mut(&5).ok_or(ExecError::InvalidMemorySize(5))?; let __ptr_u64 = __v_4.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; let (__args, __mult) = __mq.get_index_mut(__ptr_usize).ok_or(ExecError::UnboundPointer { ptr: __ptr_u64, size: 5 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 5] = __args[..5].try_into().unwrap(); __arr }; + let __v_5: G = __loaded[0]; + let __v_6: G = __loaded[1]; + let __v_7: G = __loaded[2]; + let __v_8: G = __loaded[3]; + let __v_9: G = __loaded[4]; + match __v_5.as_canonical_u64() { + 0u64 => { + let __ret: [G; OUT_739] = [__v_9]; + record.function_queries[739].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + return Err(ExecError::MatchNoCase(__v_5.as_canonical_u64())); + }, + } + }, + } + }) +} + +const INPUT_SIZE_740: usize = 8; +const IN_740: usize = 8; +const OUT_740: usize = 6; +fn aiur_fn_740( + inp: [G; IN_740], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> Result<[G; OUT_740], ExecError> { + stacker::maybe_grow(64 * 1024, 4 * 1024 * 1024, || { + let __v_0: G = inp[0]; + let __v_1: G = inp[1]; + let __v_2: G = inp[2]; + let __v_3: G = inp[3]; + let __v_4: G = inp[4]; + let __v_5: G = inp[5]; + let __v_6: G = inp[6]; + let __v_7: G = inp[7]; + match __v_2.as_canonical_u64() { + 1u64 => { + let __v_8: G = G::from_u64(0); + let __v_9: G = G::from_u64(0); + let __v_10: G = G::from_u64(1); + let __v_11: G = G::from_u64(1); + let __v_12: G = { let __values: [G; 6] = [__v_10, __v_11, __v_11, __v_11, __v_11, __v_11]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_13: G = G::from_u64(1); + let __v_14: G = G::from_u64(1); + let __v_15: G = { let __values: [G; 6] = [__v_13, __v_14, __v_14, __v_14, __v_14, __v_14]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_740] = [__v_8, __v_9, __v_0, __v_1, __v_12, __v_15]; + record.function_queries[740].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_8: G = __loaded[0]; + let __v_9: G = __loaded[1]; + let __v_10: G = __loaded[2]; + let __v_11: G = __loaded[3]; + let __v_12: G = __loaded[4]; + let __v_13: G = __loaded[5]; + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_7.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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]; + 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_740] = { let __args: [G; IN_740] = [__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[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __v_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_741] = { let __args: [G; IN_741] = [__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[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __v_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_740] = [__v_27, __v_28, __v_29, __v_30, __v_31, __v_32]; + record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_21: G = (__v_0 - __v_4); + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_22: G = G::from_u64(0); + let __v_23: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_24: G = { let __values: [G; 6] = [__v_14, __v_15, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_740] = [__v_22, __v_3, __v_0, __v_1, __v_23, __v_24]; + record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __r_arr: [G; OUT_740] = { let __args: [G; IN_740] = [__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[740].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_740] = unsafe { *(result.output.as_ptr() as *const [G; OUT_740]) }; __ret } else { aiur_fn_740(__args, record, io_buffer, __cu)? } }; + let __v_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_741] = { let __args: [G; IN_741] = [__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[741].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_741] = unsafe { *(result.output.as_ptr() as *const [G; OUT_741]) }; __ret } else { aiur_fn_741(__args, record, io_buffer, __cu)? } }; + let __v_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_740] = [__v_28, __v_29, __v_30, __v_31, __v_32, __v_33]; + record.function_queries[740].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + return Err(ExecError::MatchNoCase(__v_2.as_canonical_u64())); + }, + } + }) +} + +const INPUT_SIZE_741: usize = 15; +const IN_741: usize = 15; +const OUT_741: usize = 6; +fn aiur_fn_741( + inp: [G; IN_741], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + let __v_3: G = inp[3]; + 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]; + match __v_0.as_canonical_u64() { + 1u64 => { + let __r_arr: [G; OUT_742] = { let __args: [G; IN_742] = [__v_1, __v_2, __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[742].get_mut(&__args[..]) { if !unconstrained { *result.multiplicity += G::ONE; } let __ret: [G; OUT_742] = unsafe { *(result.output.as_ptr() as *const [G; OUT_742]) }; __ret } else { aiur_fn_742(__args, record, io_buffer, __cu)? } }; + let __v_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_741] = [__v_15, __v_16, __v_17, __v_18, __v_19, __v_20]; + record.function_queries[741].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_741] = [__v_15, __v_0, __v_1, __v_2, __v_16, __v_17]; + record.function_queries[741].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }) +} + +const INPUT_SIZE_742: usize = 14; +const IN_742: usize = 14; +const OUT_742: usize = 6; +fn aiur_fn_742( + inp: [G; IN_742], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, + unconstrained: bool, +) -> 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]; + let __v_3: G = inp[3]; + 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]; + match __v_2.as_canonical_u64() { + 0u64 => { + match __v_3.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_6.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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() { + 0u64 => { + 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(1); + let __v_24: G = { let __values: [G; 6] = [__v_22, __v_23, __v_16, __v_17, __v_18, __v_19]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = G::from_u64(0); + let __v_26: G = G::from_u64(1); + let __v_27: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_28: G = { let __values: [G; 6] = [__v_25, __v_26, __v_0, __v_1, __v_7, __v_27]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_20, __v_21, __v_4, __v_5, __v_24, __v_28]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(1); + let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_26: G = __loaded[0]; + let __v_27: G = __loaded[1]; + let __v_28: G = __loaded[2]; + let __v_29: G = __loaded[3]; + let __v_30: G = __loaded[4]; + let __v_31: G = __loaded[5]; + match __v_26.as_canonical_u64() { + 0u64 => { + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(1); + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_26: G = __loaded[0]; + let __v_27: G = __loaded[1]; + let __v_28: G = __loaded[2]; + let __v_29: G = __loaded[3]; + let __v_30: G = __loaded[4]; + let __v_31: G = __loaded[5]; + match __v_26.as_canonical_u64() { + 0u64 => { + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(1); + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 6] = [__v_28, __v_29, __v_4, __v_5, __v_6, __v_24]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = G::from_u64(0); + let __v_32: G = G::from_u64(1); + let __v_33: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_34: G = { let __values: [G; 6] = [__v_31, __v_32, __v_0, __v_1, __v_25, __v_33]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_26, __v_27, __v_22, __v_23, __v_30, __v_34]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_26: G = __loaded[0]; + let __v_27: G = __loaded[1]; + let __v_28: G = __loaded[2]; + let __v_29: G = __loaded[3]; + let __v_30: G = __loaded[4]; + let __v_31: G = __loaded[5]; + match __v_26.as_canonical_u64() { + 0u64 => { + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(1); + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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_26: G = __loaded[0]; + let __v_27: G = __loaded[1]; + let __v_28: G = __loaded[2]; + let __v_29: G = __loaded[3]; + let __v_30: G = __loaded[4]; + let __v_31: G = __loaded[5]; + match __v_26.as_canonical_u64() { + 0u64 => { + match __v_27.as_canonical_u64() { + 0u64 => { + let __v_32: G = G::from_u64(0); + let __v_33: G = G::from_u64(0); + let __v_34: G = G::from_u64(0); + let __v_35: G = G::from_u64(1); + let __v_36: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_37: G = { let __values: [G; 6] = [__v_34, __v_35, __v_0, __v_1, __v_36, __v_30]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_32, __v_33, __v_28, __v_29, __v_37, __v_40]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_32: G = __loaded[0]; + let __v_33: G = __loaded[1]; + let __v_34: G = __loaded[2]; + let __v_35: G = __loaded[3]; + let __v_36: G = __loaded[4]; + let __v_37: G = __loaded[5]; + match __v_32.as_canonical_u64() { + 0u64 => { + match __v_33.as_canonical_u64() { + 0u64 => { + let __v_38: G = G::from_u64(0); + let __v_39: G = G::from_u64(0); + let __v_40: G = G::from_u64(0); + let __v_41: G = G::from_u64(1); + let __v_42: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_43: G = { let __values: [G; 6] = [__v_40, __v_41, __v_0, __v_1, __v_42, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_38, __v_39, __v_10, __v_11, __v_43, __v_46]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].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(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_742] = [__v_38, __v_39, __v_0, __v_1, __v_40, __v_41]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + } + }, + _ => { + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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() { + 0u64 => { + 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(1); + let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + match __v_8.as_canonical_u64() { + 0u64 => { + match __v_9.as_canonical_u64() { + 0u64 => { + let __loaded: [G; 6] = { let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; let __ptr_u64 = __v_12.as_canonical_u64(); let __ptr_usize = usize::try_from(__ptr_u64).ok().ok_or(ExecError::PointerTooLarge(__ptr_u64))?; 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() { + 0u64 => { + 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(1); + let __v_24: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_25: G = { let __values: [G; 6] = [__v_22, __v_23, __v_0, __v_1, __v_24, __v_18]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_20, __v_21, __v_16, __v_17, __v_25, __v_28]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].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_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: 6 })?; if !unconstrained { *__mult += G::ONE; } let __arr: [G; 6] = __args[..6].try_into().unwrap(); __arr }; + let __v_20: G = __loaded[0]; + let __v_21: G = __loaded[1]; + let __v_22: G = __loaded[2]; + let __v_23: G = __loaded[3]; + let __v_24: G = __loaded[4]; + let __v_25: G = __loaded[5]; + match __v_20.as_canonical_u64() { + 0u64 => { + match __v_21.as_canonical_u64() { + 0u64 => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(0); + let __v_28: G = G::from_u64(0); + let __v_29: G = G::from_u64(1); + let __v_30: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_31: G = { let __values: [G; 6] = [__v_28, __v_29, __v_0, __v_1, __v_30, __v_12]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_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_742] = [__v_26, __v_27, __v_10, __v_11, __v_31, __v_34]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_26: G = G::from_u64(0); + let __v_27: G = G::from_u64(1); + let __v_28: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += 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_742] = [__v_26, __v_27, __v_0, __v_1, __v_28, __v_29]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + _ => { + let __v_14: G = G::from_u64(0); + let __v_15: G = G::from_u64(1); + let __v_16: G = { let __values: [G; 6] = [__v_2, __v_3, __v_4, __v_5, __v_6, __v_7]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __v_17: G = { let __values: [G; 6] = [__v_8, __v_9, __v_10, __v_11, __v_12, __v_13]; let __mq = record.memory_queries.get_mut(&6).ok_or(ExecError::InvalidMemorySize(6))?; if let Some(result) = __mq.get_mut(&__values[..]) { if !unconstrained { *result.multiplicity += G::ONE; } result.output[0] } else { let __ptr = G::from_usize(__mq.len()); __mq.insert(&__values[..], &[__ptr], G::from_bool(!unconstrained)); __ptr } }; + let __ret: [G; OUT_742] = [__v_14, __v_15, __v_0, __v_1, __v_16, __v_17]; + record.function_queries[742].insert(&inp[..], &__ret[..], G::from_bool(!unconstrained)); + return Ok(__ret); + }, + } + }, + } + }) +} + +pub(crate) fn execute_generated( + fun_idx: usize, + args: &[G], + record: &mut QueryRecord, + io_buffer: &mut IOBuffer, +) -> Result, ExecError> { + match fun_idx as u64 { + 0u64 => { + let __inp: [G; IN_0] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_0(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 1u64 => { + let __inp: [G; IN_1] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_1(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 2u64 => { + let __inp: [G; IN_2] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_2(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 3u64 => { + let __inp: [G; IN_3] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_3(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 4u64 => { + let __inp: [G; IN_4] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_4(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 5u64 => { + let __inp: [G; IN_5] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_5(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 6u64 => { + let __inp: [G; IN_6] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_6(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 7u64 => { + let __inp: [G; IN_7] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_7(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 8u64 => { + let __inp: [G; IN_8] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_8(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 9u64 => { + let __inp: [G; IN_9] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_9(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 10u64 => { + let __inp: [G; IN_10] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_10(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 11u64 => { + let __inp: [G; IN_11] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_11(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 12u64 => { + let __inp: [G; IN_12] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_12(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 13u64 => { + let __inp: [G; IN_13] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_13(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 14u64 => { + let __inp: [G; IN_14] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_14(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 15u64 => { + let __inp: [G; IN_15] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_15(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 16u64 => { + let __inp: [G; IN_16] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_16(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 17u64 => { + let __inp: [G; IN_17] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_17(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 18u64 => { + let __inp: [G; IN_18] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_18(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 19u64 => { + let __inp: [G; IN_19] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_19(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 20u64 => { + let __inp: [G; IN_20] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_20(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 21u64 => { + let __inp: [G; IN_21] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_21(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 22u64 => { + let __inp: [G; IN_22] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_22(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 23u64 => { + let __inp: [G; IN_23] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_23(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 24u64 => { + let __inp: [G; IN_24] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_24(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 25u64 => { + let __inp: [G; IN_25] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_25(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 26u64 => { + let __inp: [G; IN_26] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_26(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 27u64 => { + let __inp: [G; IN_27] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_27(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 28u64 => { + let __inp: [G; IN_28] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_28(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 29u64 => { + let __inp: [G; IN_29] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_29(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 30u64 => { + let __inp: [G; IN_30] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_30(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 31u64 => { + let __inp: [G; IN_31] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_31(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 32u64 => { + let __inp: [G; IN_32] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_32(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 33u64 => { + let __inp: [G; IN_33] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_33(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 34u64 => { + let __inp: [G; IN_34] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_34(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 35u64 => { + let __inp: [G; IN_35] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_35(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 36u64 => { + let __inp: [G; IN_36] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_36(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 37u64 => { + let __inp: [G; IN_37] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_37(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 38u64 => { + let __inp: [G; IN_38] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_38(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 39u64 => { + let __inp: [G; IN_39] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_39(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 40u64 => { + let __inp: [G; IN_40] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_40(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 41u64 => { + let __inp: [G; IN_41] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_41(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 42u64 => { + let __inp: [G; IN_42] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_42(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 43u64 => { + let __inp: [G; IN_43] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_43(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 44u64 => { + let __inp: [G; IN_44] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_44(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 45u64 => { + let __inp: [G; IN_45] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_45(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 46u64 => { + let __inp: [G; IN_46] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_46(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 47u64 => { + let __inp: [G; IN_47] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_47(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 48u64 => { + let __inp: [G; IN_48] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_48(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 49u64 => { + let __inp: [G; IN_49] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_49(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 50u64 => { + let __inp: [G; IN_50] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_50(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 51u64 => { + let __inp: [G; IN_51] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_51(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 52u64 => { + let __inp: [G; IN_52] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_52(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 53u64 => { + let __inp: [G; IN_53] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_53(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 54u64 => { + let __inp: [G; IN_54] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_54(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 55u64 => { + let __inp: [G; IN_55] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_55(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 56u64 => { + let __inp: [G; IN_56] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_56(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 57u64 => { + let __inp: [G; IN_57] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_57(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 58u64 => { + let __inp: [G; IN_58] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_58(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 59u64 => { + let __inp: [G; IN_59] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_59(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 60u64 => { + let __inp: [G; IN_60] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_60(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 61u64 => { + let __inp: [G; IN_61] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_61(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 62u64 => { + let __inp: [G; IN_62] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_62(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 63u64 => { + let __inp: [G; IN_63] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_63(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 64u64 => { + let __inp: [G; IN_64] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_64(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 65u64 => { + let __inp: [G; IN_65] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_65(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 66u64 => { + let __inp: [G; IN_66] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_66(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 67u64 => { + let __inp: [G; IN_67] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_67(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 68u64 => { + let __inp: [G; IN_68] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_68(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 69u64 => { + let __inp: [G; IN_69] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_69(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 70u64 => { + let __inp: [G; IN_70] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_70(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 71u64 => { + let __inp: [G; IN_71] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_71(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 72u64 => { + let __inp: [G; IN_72] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_72(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 73u64 => { + let __inp: [G; IN_73] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_73(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 74u64 => { + let __inp: [G; IN_74] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_74(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 75u64 => { + let __inp: [G; IN_75] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_75(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 76u64 => { + let __inp: [G; IN_76] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_76(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 77u64 => { + let __inp: [G; IN_77] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_77(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 78u64 => { + let __inp: [G; IN_78] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_78(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 79u64 => { + let __inp: [G; IN_79] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_79(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 80u64 => { + let __inp: [G; IN_80] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_80(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 81u64 => { + let __inp: [G; IN_81] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_81(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 82u64 => { + let __inp: [G; IN_82] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_82(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 83u64 => { + let __inp: [G; IN_83] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_83(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 84u64 => { + let __inp: [G; IN_84] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_84(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 85u64 => { + let __inp: [G; IN_85] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_85(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 86u64 => { + let __inp: [G; IN_86] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_86(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 87u64 => { + let __inp: [G; IN_87] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_87(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 88u64 => { + let __inp: [G; IN_88] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_88(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 89u64 => { + let __inp: [G; IN_89] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_89(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 90u64 => { + let __inp: [G; IN_90] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_90(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 91u64 => { + let __inp: [G; IN_91] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_91(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 92u64 => { + let __inp: [G; IN_92] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_92(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 93u64 => { + let __inp: [G; IN_93] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_93(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 94u64 => { + let __inp: [G; IN_94] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_94(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 95u64 => { + let __inp: [G; IN_95] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_95(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 96u64 => { + let __inp: [G; IN_96] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_96(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 97u64 => { + let __inp: [G; IN_97] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_97(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 98u64 => { + let __inp: [G; IN_98] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_98(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 99u64 => { + let __inp: [G; IN_99] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_99(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 100u64 => { + let __inp: [G; IN_100] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_100(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 101u64 => { + let __inp: [G; IN_101] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_101(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 102u64 => { + let __inp: [G; IN_102] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_102(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 103u64 => { + let __inp: [G; IN_103] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_103(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 104u64 => { + let __inp: [G; IN_104] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_104(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 105u64 => { + let __inp: [G; IN_105] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_105(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 106u64 => { + let __inp: [G; IN_106] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_106(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 107u64 => { + let __inp: [G; IN_107] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_107(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 108u64 => { + let __inp: [G; IN_108] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_108(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 109u64 => { + let __inp: [G; IN_109] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_109(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 110u64 => { + let __inp: [G; IN_110] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_110(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 111u64 => { + let __inp: [G; IN_111] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_111(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 112u64 => { + let __inp: [G; IN_112] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_112(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 113u64 => { + let __inp: [G; IN_113] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_113(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 114u64 => { + let __inp: [G; IN_114] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_114(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 115u64 => { + let __inp: [G; IN_115] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_115(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 116u64 => { + let __inp: [G; IN_116] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_116(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 117u64 => { + let __inp: [G; IN_117] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_117(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 118u64 => { + let __inp: [G; IN_118] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_118(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 119u64 => { + let __inp: [G; IN_119] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_119(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 120u64 => { + let __inp: [G; IN_120] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_120(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 121u64 => { + let __inp: [G; IN_121] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_121(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 122u64 => { + let __inp: [G; IN_122] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_122(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 123u64 => { + let __inp: [G; IN_123] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_123(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 124u64 => { + let __inp: [G; IN_124] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_124(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 125u64 => { + let __inp: [G; IN_125] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_125(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 126u64 => { + let __inp: [G; IN_126] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_126(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 127u64 => { + let __inp: [G; IN_127] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_127(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 128u64 => { + let __inp: [G; IN_128] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_128(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 129u64 => { + let __inp: [G; IN_129] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_129(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 130u64 => { + let __inp: [G; IN_130] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_130(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 131u64 => { + let __inp: [G; IN_131] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_131(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 132u64 => { + let __inp: [G; IN_132] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_132(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 133u64 => { + let __inp: [G; IN_133] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_133(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 134u64 => { + let __inp: [G; IN_134] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_134(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 135u64 => { + let __inp: [G; IN_135] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_135(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 136u64 => { + let __inp: [G; IN_136] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_136(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 137u64 => { + let __inp: [G; IN_137] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_137(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 138u64 => { + let __inp: [G; IN_138] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_138(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 139u64 => { + let __inp: [G; IN_139] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_139(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 140u64 => { + let __inp: [G; IN_140] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_140(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 141u64 => { + let __inp: [G; IN_141] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_141(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 142u64 => { + let __inp: [G; IN_142] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_142(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 143u64 => { + let __inp: [G; IN_143] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_143(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 144u64 => { + let __inp: [G; IN_144] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_144(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 145u64 => { + let __inp: [G; IN_145] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_145(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 146u64 => { + let __inp: [G; IN_146] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_146(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 147u64 => { + let __inp: [G; IN_147] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_147(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 148u64 => { + let __inp: [G; IN_148] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_148(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 149u64 => { + let __inp: [G; IN_149] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_149(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 150u64 => { + let __inp: [G; IN_150] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_150(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 151u64 => { + let __inp: [G; IN_151] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_151(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 152u64 => { + let __inp: [G; IN_152] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_152(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 153u64 => { + let __inp: [G; IN_153] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_153(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 154u64 => { + let __inp: [G; IN_154] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_154(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 155u64 => { + let __inp: [G; IN_155] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_155(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 156u64 => { + let __inp: [G; IN_156] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_156(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 157u64 => { + let __inp: [G; IN_157] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_157(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 158u64 => { + let __inp: [G; IN_158] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_158(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 159u64 => { + let __inp: [G; IN_159] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_159(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 160u64 => { + let __inp: [G; IN_160] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_160(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 161u64 => { + let __inp: [G; IN_161] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_161(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 162u64 => { + let __inp: [G; IN_162] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_162(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 163u64 => { + let __inp: [G; IN_163] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_163(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 164u64 => { + let __inp: [G; IN_164] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_164(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 165u64 => { + let __inp: [G; IN_165] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_165(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 166u64 => { + let __inp: [G; IN_166] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_166(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 167u64 => { + let __inp: [G; IN_167] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_167(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 168u64 => { + let __inp: [G; IN_168] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_168(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 169u64 => { + let __inp: [G; IN_169] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_169(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 170u64 => { + let __inp: [G; IN_170] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_170(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 171u64 => { + let __inp: [G; IN_171] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_171(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 172u64 => { + let __inp: [G; IN_172] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_172(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 173u64 => { + let __inp: [G; IN_173] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_173(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 174u64 => { + let __inp: [G; IN_174] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_174(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 175u64 => { + let __inp: [G; IN_175] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_175(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 176u64 => { + let __inp: [G; IN_176] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_176(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 177u64 => { + let __inp: [G; IN_177] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_177(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 178u64 => { + let __inp: [G; IN_178] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_178(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 179u64 => { + let __inp: [G; IN_179] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_179(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 180u64 => { + let __inp: [G; IN_180] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_180(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 181u64 => { + let __inp: [G; IN_181] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_181(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 182u64 => { + let __inp: [G; IN_182] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_182(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 183u64 => { + let __inp: [G; IN_183] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_183(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 184u64 => { + let __inp: [G; IN_184] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_184(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 185u64 => { + let __inp: [G; IN_185] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_185(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 186u64 => { + let __inp: [G; IN_186] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_186(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 187u64 => { + let __inp: [G; IN_187] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_187(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 188u64 => { + let __inp: [G; IN_188] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_188(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 189u64 => { + let __inp: [G; IN_189] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_189(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 190u64 => { + let __inp: [G; IN_190] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_190(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 191u64 => { + let __inp: [G; IN_191] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_191(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 192u64 => { + let __inp: [G; IN_192] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_192(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 193u64 => { + let __inp: [G; IN_193] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_193(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 194u64 => { + let __inp: [G; IN_194] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_194(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 195u64 => { + let __inp: [G; IN_195] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_195(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 196u64 => { + let __inp: [G; IN_196] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_196(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 197u64 => { + let __inp: [G; IN_197] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_197(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 198u64 => { + let __inp: [G; IN_198] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_198(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 199u64 => { + let __inp: [G; IN_199] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_199(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 200u64 => { + let __inp: [G; IN_200] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_200(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 201u64 => { + let __inp: [G; IN_201] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_201(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 202u64 => { + let __inp: [G; IN_202] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_202(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 203u64 => { + let __inp: [G; IN_203] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_203(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 204u64 => { + let __inp: [G; IN_204] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_204(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 205u64 => { + let __inp: [G; IN_205] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_205(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 206u64 => { + let __inp: [G; IN_206] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_206(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 207u64 => { + let __inp: [G; IN_207] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_207(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 208u64 => { + let __inp: [G; IN_208] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_208(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 209u64 => { + let __inp: [G; IN_209] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_209(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 210u64 => { + let __inp: [G; IN_210] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_210(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 211u64 => { + let __inp: [G; IN_211] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_211(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 212u64 => { + let __inp: [G; IN_212] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_212(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 213u64 => { + let __inp: [G; IN_213] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_213(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 214u64 => { + let __inp: [G; IN_214] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_214(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 215u64 => { + let __inp: [G; IN_215] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_215(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 216u64 => { + let __inp: [G; IN_216] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_216(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 217u64 => { + let __inp: [G; IN_217] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_217(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 218u64 => { + let __inp: [G; IN_218] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_218(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 219u64 => { + let __inp: [G; IN_219] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_219(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 220u64 => { + let __inp: [G; IN_220] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_220(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 221u64 => { + let __inp: [G; IN_221] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_221(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 222u64 => { + let __inp: [G; IN_222] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_222(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 223u64 => { + let __inp: [G; IN_223] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_223(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 224u64 => { + let __inp: [G; IN_224] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_224(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 225u64 => { + let __inp: [G; IN_225] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_225(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 226u64 => { + let __inp: [G; IN_226] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_226(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 227u64 => { + let __inp: [G; IN_227] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_227(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 228u64 => { + let __inp: [G; IN_228] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_228(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 229u64 => { + let __inp: [G; IN_229] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_229(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 230u64 => { + let __inp: [G; IN_230] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_230(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 231u64 => { + let __inp: [G; IN_231] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_231(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 232u64 => { + let __inp: [G; IN_232] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_232(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 233u64 => { + let __inp: [G; IN_233] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_233(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 234u64 => { + let __inp: [G; IN_234] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_234(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 235u64 => { + let __inp: [G; IN_235] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_235(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 236u64 => { + let __inp: [G; IN_236] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_236(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 237u64 => { + let __inp: [G; IN_237] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_237(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 238u64 => { + let __inp: [G; IN_238] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_238(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 239u64 => { + let __inp: [G; IN_239] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_239(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 240u64 => { + let __inp: [G; IN_240] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_240(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 241u64 => { + let __inp: [G; IN_241] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_241(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 242u64 => { + let __inp: [G; IN_242] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_242(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 243u64 => { + let __inp: [G; IN_243] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_243(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 244u64 => { + let __inp: [G; IN_244] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_244(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 245u64 => { + let __inp: [G; IN_245] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_245(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 246u64 => { + let __inp: [G; IN_246] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_246(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 247u64 => { + let __inp: [G; IN_247] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_247(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 248u64 => { + let __inp: [G; IN_248] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_248(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 249u64 => { + let __inp: [G; IN_249] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_249(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 250u64 => { + let __inp: [G; IN_250] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_250(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 251u64 => { + let __inp: [G; IN_251] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_251(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 252u64 => { + let __inp: [G; IN_252] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_252(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 253u64 => { + let __inp: [G; IN_253] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_253(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 254u64 => { + let __inp: [G; IN_254] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_254(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 255u64 => { + let __inp: [G; IN_255] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_255(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 256u64 => { + let __inp: [G; IN_256] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_256(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 257u64 => { + let __inp: [G; IN_257] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_257(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 258u64 => { + let __inp: [G; IN_258] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_258(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 259u64 => { + let __inp: [G; IN_259] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_259(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 260u64 => { + let __inp: [G; IN_260] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_260(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 261u64 => { + let __inp: [G; IN_261] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_261(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 262u64 => { + let __inp: [G; IN_262] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_262(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 263u64 => { + let __inp: [G; IN_263] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_263(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 264u64 => { + let __inp: [G; IN_264] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_264(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 265u64 => { + let __inp: [G; IN_265] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_265(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 266u64 => { + let __inp: [G; IN_266] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_266(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 267u64 => { + let __inp: [G; IN_267] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_267(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 268u64 => { + let __inp: [G; IN_268] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_268(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 269u64 => { + let __inp: [G; IN_269] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_269(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 270u64 => { + let __inp: [G; IN_270] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_270(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 271u64 => { + let __inp: [G; IN_271] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_271(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 272u64 => { + let __inp: [G; IN_272] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_272(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 273u64 => { + let __inp: [G; IN_273] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_273(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 274u64 => { + let __inp: [G; IN_274] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_274(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 275u64 => { + let __inp: [G; IN_275] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_275(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 276u64 => { + let __inp: [G; IN_276] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_276(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 277u64 => { + let __inp: [G; IN_277] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_277(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 278u64 => { + let __inp: [G; IN_278] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_278(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 279u64 => { + let __inp: [G; IN_279] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_279(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 280u64 => { + let __inp: [G; IN_280] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_280(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 281u64 => { + let __inp: [G; IN_281] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_281(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 282u64 => { + let __inp: [G; IN_282] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_282(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 283u64 => { + let __inp: [G; IN_283] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_283(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 284u64 => { + let __inp: [G; IN_284] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_284(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 285u64 => { + let __inp: [G; IN_285] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_285(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 286u64 => { + let __inp: [G; IN_286] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_286(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 287u64 => { + let __inp: [G; IN_287] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_287(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 288u64 => { + let __inp: [G; IN_288] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_288(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 289u64 => { + let __inp: [G; IN_289] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_289(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 290u64 => { + let __inp: [G; IN_290] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_290(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 291u64 => { + let __inp: [G; IN_291] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_291(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 292u64 => { + let __inp: [G; IN_292] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_292(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 293u64 => { + let __inp: [G; IN_293] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_293(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 294u64 => { + let __inp: [G; IN_294] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_294(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 295u64 => { + let __inp: [G; IN_295] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_295(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 296u64 => { + let __inp: [G; IN_296] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_296(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 297u64 => { + let __inp: [G; IN_297] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_297(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 298u64 => { + let __inp: [G; IN_298] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_298(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 299u64 => { + let __inp: [G; IN_299] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_299(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 300u64 => { + let __inp: [G; IN_300] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_300(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 301u64 => { + let __inp: [G; IN_301] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_301(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 302u64 => { + let __inp: [G; IN_302] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_302(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 303u64 => { + let __inp: [G; IN_303] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_303(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 304u64 => { + let __inp: [G; IN_304] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_304(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 305u64 => { + let __inp: [G; IN_305] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_305(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 306u64 => { + let __inp: [G; IN_306] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_306(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 307u64 => { + let __inp: [G; IN_307] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_307(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 308u64 => { + let __inp: [G; IN_308] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_308(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 309u64 => { + let __inp: [G; IN_309] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_309(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 310u64 => { + let __inp: [G; IN_310] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_310(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 311u64 => { + let __inp: [G; IN_311] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_311(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 312u64 => { + let __inp: [G; IN_312] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_312(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 313u64 => { + let __inp: [G; IN_313] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_313(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 314u64 => { + let __inp: [G; IN_314] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_314(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 315u64 => { + let __inp: [G; IN_315] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_315(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 316u64 => { + let __inp: [G; IN_316] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_316(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 317u64 => { + let __inp: [G; IN_317] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_317(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 318u64 => { + let __inp: [G; IN_318] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_318(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 319u64 => { + let __inp: [G; IN_319] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_319(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 320u64 => { + let __inp: [G; IN_320] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_320(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 321u64 => { + let __inp: [G; IN_321] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_321(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 322u64 => { + let __inp: [G; IN_322] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_322(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 323u64 => { + let __inp: [G; IN_323] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_323(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 324u64 => { + let __inp: [G; IN_324] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_324(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 325u64 => { + let __inp: [G; IN_325] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_325(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 326u64 => { + let __inp: [G; IN_326] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_326(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 327u64 => { + let __inp: [G; IN_327] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_327(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 328u64 => { + let __inp: [G; IN_328] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_328(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 329u64 => { + let __inp: [G; IN_329] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_329(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 330u64 => { + let __inp: [G; IN_330] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_330(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 331u64 => { + let __inp: [G; IN_331] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_331(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 332u64 => { + let __inp: [G; IN_332] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_332(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 333u64 => { + let __inp: [G; IN_333] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_333(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 334u64 => { + let __inp: [G; IN_334] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_334(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 335u64 => { + let __inp: [G; IN_335] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_335(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 336u64 => { + let __inp: [G; IN_336] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_336(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 337u64 => { + let __inp: [G; IN_337] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_337(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 338u64 => { + let __inp: [G; IN_338] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_338(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 339u64 => { + let __inp: [G; IN_339] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_339(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 340u64 => { + let __inp: [G; IN_340] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_340(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 341u64 => { + let __inp: [G; IN_341] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_341(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 342u64 => { + let __inp: [G; IN_342] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_342(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 343u64 => { + let __inp: [G; IN_343] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_343(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 344u64 => { + let __inp: [G; IN_344] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_344(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 345u64 => { + let __inp: [G; IN_345] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_345(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 346u64 => { + let __inp: [G; IN_346] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_346(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 347u64 => { + let __inp: [G; IN_347] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_347(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 348u64 => { + let __inp: [G; IN_348] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_348(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 349u64 => { + let __inp: [G; IN_349] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_349(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 350u64 => { + let __inp: [G; IN_350] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_350(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 351u64 => { + let __inp: [G; IN_351] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_351(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 352u64 => { + let __inp: [G; IN_352] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_352(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 353u64 => { + let __inp: [G; IN_353] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_353(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 354u64 => { + let __inp: [G; IN_354] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_354(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 355u64 => { + let __inp: [G; IN_355] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_355(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 356u64 => { + let __inp: [G; IN_356] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_356(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 357u64 => { + let __inp: [G; IN_357] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_357(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 358u64 => { + let __inp: [G; IN_358] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_358(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 359u64 => { + let __inp: [G; IN_359] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_359(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 360u64 => { + let __inp: [G; IN_360] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_360(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 361u64 => { + let __inp: [G; IN_361] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_361(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 362u64 => { + let __inp: [G; IN_362] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_362(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 363u64 => { + let __inp: [G; IN_363] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_363(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 364u64 => { + let __inp: [G; IN_364] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_364(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 365u64 => { + let __inp: [G; IN_365] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_365(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 366u64 => { + let __inp: [G; IN_366] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_366(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 367u64 => { + let __inp: [G; IN_367] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_367(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 368u64 => { + let __inp: [G; IN_368] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_368(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 369u64 => { + let __inp: [G; IN_369] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_369(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 370u64 => { + let __inp: [G; IN_370] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_370(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 371u64 => { + let __inp: [G; IN_371] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_371(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 372u64 => { + let __inp: [G; IN_372] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_372(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 373u64 => { + let __inp: [G; IN_373] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_373(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 374u64 => { + let __inp: [G; IN_374] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_374(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 375u64 => { + let __inp: [G; IN_375] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_375(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 376u64 => { + let __inp: [G; IN_376] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_376(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 377u64 => { + let __inp: [G; IN_377] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_377(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 378u64 => { + let __inp: [G; IN_378] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_378(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 379u64 => { + let __inp: [G; IN_379] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_379(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 380u64 => { + let __inp: [G; IN_380] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_380(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 381u64 => { + let __inp: [G; IN_381] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_381(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 382u64 => { + let __inp: [G; IN_382] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_382(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 383u64 => { + let __inp: [G; IN_383] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_383(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 384u64 => { + let __inp: [G; IN_384] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_384(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 385u64 => { + let __inp: [G; IN_385] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_385(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 386u64 => { + let __inp: [G; IN_386] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_386(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 387u64 => { + let __inp: [G; IN_387] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_387(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 388u64 => { + let __inp: [G; IN_388] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_388(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 389u64 => { + let __inp: [G; IN_389] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_389(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 390u64 => { + let __inp: [G; IN_390] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_390(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 391u64 => { + let __inp: [G; IN_391] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_391(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 392u64 => { + let __inp: [G; IN_392] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_392(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 393u64 => { + let __inp: [G; IN_393] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_393(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 394u64 => { + let __inp: [G; IN_394] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_394(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 395u64 => { + let __inp: [G; IN_395] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_395(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 396u64 => { + let __inp: [G; IN_396] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_396(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 397u64 => { + let __inp: [G; IN_397] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_397(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 398u64 => { + let __inp: [G; IN_398] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_398(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 399u64 => { + let __inp: [G; IN_399] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_399(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 400u64 => { + let __inp: [G; IN_400] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_400(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 401u64 => { + let __inp: [G; IN_401] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_401(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 402u64 => { + let __inp: [G; IN_402] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_402(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 403u64 => { + let __inp: [G; IN_403] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_403(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 404u64 => { + let __inp: [G; IN_404] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_404(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 405u64 => { + let __inp: [G; IN_405] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_405(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 406u64 => { + let __inp: [G; IN_406] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_406(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 407u64 => { + let __inp: [G; IN_407] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_407(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 408u64 => { + let __inp: [G; IN_408] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_408(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 409u64 => { + let __inp: [G; IN_409] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_409(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 410u64 => { + let __inp: [G; IN_410] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_410(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 411u64 => { + let __inp: [G; IN_411] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_411(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 412u64 => { + let __inp: [G; IN_412] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_412(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 413u64 => { + let __inp: [G; IN_413] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_413(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 414u64 => { + let __inp: [G; IN_414] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_414(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 415u64 => { + let __inp: [G; IN_415] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_415(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 416u64 => { + let __inp: [G; IN_416] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_416(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 417u64 => { + let __inp: [G; IN_417] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_417(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 418u64 => { + let __inp: [G; IN_418] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_418(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 419u64 => { + let __inp: [G; IN_419] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_419(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 420u64 => { + let __inp: [G; IN_420] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_420(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 421u64 => { + let __inp: [G; IN_421] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_421(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 422u64 => { + let __inp: [G; IN_422] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_422(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 423u64 => { + let __inp: [G; IN_423] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_423(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 424u64 => { + let __inp: [G; IN_424] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_424(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 425u64 => { + let __inp: [G; IN_425] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_425(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 426u64 => { + let __inp: [G; IN_426] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_426(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 427u64 => { + let __inp: [G; IN_427] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_427(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 428u64 => { + let __inp: [G; IN_428] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_428(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 429u64 => { + let __inp: [G; IN_429] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_429(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 430u64 => { + let __inp: [G; IN_430] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_430(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 431u64 => { + let __inp: [G; IN_431] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_431(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 432u64 => { + let __inp: [G; IN_432] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_432(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 433u64 => { + let __inp: [G; IN_433] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_433(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 434u64 => { + let __inp: [G; IN_434] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_434(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 435u64 => { + let __inp: [G; IN_435] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_435(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 436u64 => { + let __inp: [G; IN_436] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_436(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 437u64 => { + let __inp: [G; IN_437] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_437(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 438u64 => { + let __inp: [G; IN_438] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_438(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 439u64 => { + let __inp: [G; IN_439] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_439(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 440u64 => { + let __inp: [G; IN_440] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_440(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 441u64 => { + let __inp: [G; IN_441] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_441(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 442u64 => { + let __inp: [G; IN_442] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_442(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 443u64 => { + let __inp: [G; IN_443] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_443(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 444u64 => { + let __inp: [G; IN_444] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_444(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 445u64 => { + let __inp: [G; IN_445] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_445(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 446u64 => { + let __inp: [G; IN_446] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_446(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 447u64 => { + let __inp: [G; IN_447] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_447(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 448u64 => { + let __inp: [G; IN_448] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_448(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 449u64 => { + let __inp: [G; IN_449] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_449(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 450u64 => { + let __inp: [G; IN_450] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_450(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 451u64 => { + let __inp: [G; IN_451] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_451(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 452u64 => { + let __inp: [G; IN_452] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_452(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 453u64 => { + let __inp: [G; IN_453] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_453(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 454u64 => { + let __inp: [G; IN_454] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_454(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 455u64 => { + let __inp: [G; IN_455] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_455(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 456u64 => { + let __inp: [G; IN_456] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_456(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 457u64 => { + let __inp: [G; IN_457] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_457(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 458u64 => { + let __inp: [G; IN_458] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_458(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 459u64 => { + let __inp: [G; IN_459] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_459(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 460u64 => { + let __inp: [G; IN_460] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_460(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 461u64 => { + let __inp: [G; IN_461] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_461(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 462u64 => { + let __inp: [G; IN_462] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_462(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 463u64 => { + let __inp: [G; IN_463] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_463(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 464u64 => { + let __inp: [G; IN_464] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_464(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 465u64 => { + let __inp: [G; IN_465] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_465(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 466u64 => { + let __inp: [G; IN_466] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_466(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 467u64 => { + let __inp: [G; IN_467] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_467(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 468u64 => { + let __inp: [G; IN_468] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_468(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 469u64 => { + let __inp: [G; IN_469] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_469(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 470u64 => { + let __inp: [G; IN_470] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_470(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 471u64 => { + let __inp: [G; IN_471] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_471(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 472u64 => { + let __inp: [G; IN_472] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_472(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 473u64 => { + let __inp: [G; IN_473] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_473(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 474u64 => { + let __inp: [G; IN_474] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_474(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 475u64 => { + let __inp: [G; IN_475] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_475(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 476u64 => { + let __inp: [G; IN_476] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_476(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 477u64 => { + let __inp: [G; IN_477] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_477(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 478u64 => { + let __inp: [G; IN_478] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_478(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 479u64 => { + let __inp: [G; IN_479] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_479(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 480u64 => { + let __inp: [G; IN_480] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_480(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 481u64 => { + let __inp: [G; IN_481] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_481(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 482u64 => { + let __inp: [G; IN_482] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_482(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 483u64 => { + let __inp: [G; IN_483] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_483(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 484u64 => { + let __inp: [G; IN_484] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_484(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 485u64 => { + let __inp: [G; IN_485] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_485(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 486u64 => { + let __inp: [G; IN_486] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_486(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 487u64 => { + let __inp: [G; IN_487] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_487(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 488u64 => { + let __inp: [G; IN_488] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_488(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 489u64 => { + let __inp: [G; IN_489] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_489(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 490u64 => { + let __inp: [G; IN_490] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_490(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 491u64 => { + let __inp: [G; IN_491] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_491(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 492u64 => { + let __inp: [G; IN_492] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_492(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 493u64 => { + let __inp: [G; IN_493] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_493(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 494u64 => { + let __inp: [G; IN_494] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_494(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 495u64 => { + let __inp: [G; IN_495] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_495(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 496u64 => { + let __inp: [G; IN_496] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_496(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 497u64 => { + let __inp: [G; IN_497] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_497(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 498u64 => { + let __inp: [G; IN_498] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_498(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 499u64 => { + let __inp: [G; IN_499] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_499(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 500u64 => { + let __inp: [G; IN_500] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_500(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 501u64 => { + let __inp: [G; IN_501] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_501(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 502u64 => { + let __inp: [G; IN_502] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_502(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 503u64 => { + let __inp: [G; IN_503] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_503(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 504u64 => { + let __inp: [G; IN_504] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_504(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 505u64 => { + let __inp: [G; IN_505] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_505(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 506u64 => { + let __inp: [G; IN_506] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_506(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 507u64 => { + let __inp: [G; IN_507] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_507(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 508u64 => { + let __inp: [G; IN_508] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_508(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 509u64 => { + let __inp: [G; IN_509] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_509(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 510u64 => { + let __inp: [G; IN_510] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_510(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 511u64 => { + let __inp: [G; IN_511] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_511(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 512u64 => { + let __inp: [G; IN_512] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_512(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 513u64 => { + let __inp: [G; IN_513] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_513(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 514u64 => { + let __inp: [G; IN_514] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_514(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 515u64 => { + let __inp: [G; IN_515] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_515(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 516u64 => { + let __inp: [G; IN_516] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_516(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 517u64 => { + let __inp: [G; IN_517] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_517(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 518u64 => { + let __inp: [G; IN_518] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_518(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 519u64 => { + let __inp: [G; IN_519] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_519(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 520u64 => { + let __inp: [G; IN_520] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_520(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 521u64 => { + let __inp: [G; IN_521] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_521(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 522u64 => { + let __inp: [G; IN_522] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_522(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 523u64 => { + let __inp: [G; IN_523] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_523(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 524u64 => { + let __inp: [G; IN_524] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_524(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 525u64 => { + let __inp: [G; IN_525] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_525(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 526u64 => { + let __inp: [G; IN_526] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_526(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 527u64 => { + let __inp: [G; IN_527] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_527(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 528u64 => { + let __inp: [G; IN_528] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_528(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 529u64 => { + let __inp: [G; IN_529] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_529(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 530u64 => { + let __inp: [G; IN_530] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_530(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 531u64 => { + let __inp: [G; IN_531] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_531(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 532u64 => { + let __inp: [G; IN_532] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_532(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 533u64 => { + let __inp: [G; IN_533] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_533(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 534u64 => { + let __inp: [G; IN_534] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_534(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 535u64 => { + let __inp: [G; IN_535] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_535(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 536u64 => { + let __inp: [G; IN_536] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_536(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 537u64 => { + let __inp: [G; IN_537] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_537(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 538u64 => { + let __inp: [G; IN_538] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_538(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 539u64 => { + let __inp: [G; IN_539] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_539(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 540u64 => { + let __inp: [G; IN_540] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_540(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 541u64 => { + let __inp: [G; IN_541] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_541(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 542u64 => { + let __inp: [G; IN_542] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_542(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 543u64 => { + let __inp: [G; IN_543] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_543(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 544u64 => { + let __inp: [G; IN_544] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_544(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 545u64 => { + let __inp: [G; IN_545] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_545(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 546u64 => { + let __inp: [G; IN_546] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_546(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 547u64 => { + let __inp: [G; IN_547] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_547(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 548u64 => { + let __inp: [G; IN_548] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_548(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 549u64 => { + let __inp: [G; IN_549] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_549(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 550u64 => { + let __inp: [G; IN_550] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_550(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 551u64 => { + let __inp: [G; IN_551] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_551(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 552u64 => { + let __inp: [G; IN_552] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_552(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 553u64 => { + let __inp: [G; IN_553] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_553(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 554u64 => { + let __inp: [G; IN_554] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_554(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 555u64 => { + let __inp: [G; IN_555] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_555(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 556u64 => { + let __inp: [G; IN_556] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_556(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 557u64 => { + let __inp: [G; IN_557] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_557(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 558u64 => { + let __inp: [G; IN_558] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_558(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 559u64 => { + let __inp: [G; IN_559] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_559(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 560u64 => { + let __inp: [G; IN_560] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_560(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 561u64 => { + let __inp: [G; IN_561] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_561(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 562u64 => { + let __inp: [G; IN_562] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_562(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 563u64 => { + let __inp: [G; IN_563] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_563(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 564u64 => { + let __inp: [G; IN_564] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_564(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 565u64 => { + let __inp: [G; IN_565] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_565(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 566u64 => { + let __inp: [G; IN_566] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_566(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 567u64 => { + let __inp: [G; IN_567] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_567(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 568u64 => { + let __inp: [G; IN_568] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_568(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 569u64 => { + let __inp: [G; IN_569] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_569(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 570u64 => { + let __inp: [G; IN_570] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_570(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 571u64 => { + let __inp: [G; IN_571] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_571(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 572u64 => { + let __inp: [G; IN_572] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_572(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 573u64 => { + let __inp: [G; IN_573] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_573(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 574u64 => { + let __inp: [G; IN_574] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_574(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 575u64 => { + let __inp: [G; IN_575] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_575(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 576u64 => { + let __inp: [G; IN_576] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_576(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 577u64 => { + let __inp: [G; IN_577] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_577(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 578u64 => { + let __inp: [G; IN_578] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_578(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 579u64 => { + let __inp: [G; IN_579] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_579(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 580u64 => { + let __inp: [G; IN_580] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_580(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 581u64 => { + let __inp: [G; IN_581] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_581(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 582u64 => { + let __inp: [G; IN_582] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_582(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 583u64 => { + let __inp: [G; IN_583] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_583(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 584u64 => { + let __inp: [G; IN_584] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_584(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 585u64 => { + let __inp: [G; IN_585] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_585(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 586u64 => { + let __inp: [G; IN_586] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_586(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 587u64 => { + let __inp: [G; IN_587] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_587(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 588u64 => { + let __inp: [G; IN_588] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_588(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 589u64 => { + let __inp: [G; IN_589] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_589(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 590u64 => { + let __inp: [G; IN_590] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_590(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 591u64 => { + let __inp: [G; IN_591] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_591(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 592u64 => { + let __inp: [G; IN_592] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_592(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 593u64 => { + let __inp: [G; IN_593] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_593(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 594u64 => { + let __inp: [G; IN_594] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_594(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 595u64 => { + let __inp: [G; IN_595] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_595(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 596u64 => { + let __inp: [G; IN_596] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_596(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 597u64 => { + let __inp: [G; IN_597] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_597(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 598u64 => { + let __inp: [G; IN_598] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_598(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 599u64 => { + let __inp: [G; IN_599] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_599(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 600u64 => { + let __inp: [G; IN_600] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_600(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 601u64 => { + let __inp: [G; IN_601] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_601(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 602u64 => { + let __inp: [G; IN_602] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_602(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 603u64 => { + let __inp: [G; IN_603] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_603(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 604u64 => { + let __inp: [G; IN_604] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_604(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 605u64 => { + let __inp: [G; IN_605] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_605(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 606u64 => { + let __inp: [G; IN_606] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_606(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 607u64 => { + let __inp: [G; IN_607] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_607(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 608u64 => { + let __inp: [G; IN_608] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_608(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 609u64 => { + let __inp: [G; IN_609] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_609(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 610u64 => { + let __inp: [G; IN_610] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_610(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 611u64 => { + let __inp: [G; IN_611] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_611(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 612u64 => { + let __inp: [G; IN_612] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_612(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 613u64 => { + let __inp: [G; IN_613] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_613(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 614u64 => { + let __inp: [G; IN_614] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_614(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 615u64 => { + let __inp: [G; IN_615] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_615(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 616u64 => { + let __inp: [G; IN_616] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_616(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 617u64 => { + let __inp: [G; IN_617] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_617(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 618u64 => { + let __inp: [G; IN_618] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_618(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 619u64 => { + let __inp: [G; IN_619] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_619(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 620u64 => { + let __inp: [G; IN_620] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_620(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 621u64 => { + let __inp: [G; IN_621] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_621(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 622u64 => { + let __inp: [G; IN_622] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_622(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 623u64 => { + let __inp: [G; IN_623] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_623(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 624u64 => { + let __inp: [G; IN_624] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_624(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 625u64 => { + let __inp: [G; IN_625] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_625(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 626u64 => { + let __inp: [G; IN_626] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_626(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 627u64 => { + let __inp: [G; IN_627] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_627(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 628u64 => { + let __inp: [G; IN_628] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_628(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 629u64 => { + let __inp: [G; IN_629] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_629(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 630u64 => { + let __inp: [G; IN_630] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_630(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 631u64 => { + let __inp: [G; IN_631] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_631(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 632u64 => { + let __inp: [G; IN_632] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_632(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 633u64 => { + let __inp: [G; IN_633] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_633(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 634u64 => { + let __inp: [G; IN_634] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_634(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 635u64 => { + let __inp: [G; IN_635] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_635(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 636u64 => { + let __inp: [G; IN_636] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_636(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 637u64 => { + let __inp: [G; IN_637] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_637(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 638u64 => { + let __inp: [G; IN_638] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_638(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 639u64 => { + let __inp: [G; IN_639] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_639(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 640u64 => { + let __inp: [G; IN_640] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_640(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 641u64 => { + let __inp: [G; IN_641] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_641(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 642u64 => { + let __inp: [G; IN_642] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_642(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 643u64 => { + let __inp: [G; IN_643] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_643(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 644u64 => { + let __inp: [G; IN_644] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_644(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 645u64 => { + let __inp: [G; IN_645] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_645(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 646u64 => { + let __inp: [G; IN_646] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_646(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 647u64 => { + let __inp: [G; IN_647] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_647(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 648u64 => { + let __inp: [G; IN_648] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_648(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 649u64 => { + let __inp: [G; IN_649] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_649(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 650u64 => { + let __inp: [G; IN_650] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_650(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 651u64 => { + let __inp: [G; IN_651] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_651(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 652u64 => { + let __inp: [G; IN_652] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_652(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 653u64 => { + let __inp: [G; IN_653] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_653(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 654u64 => { + let __inp: [G; IN_654] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_654(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 655u64 => { + let __inp: [G; IN_655] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_655(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 656u64 => { + let __inp: [G; IN_656] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_656(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 657u64 => { + let __inp: [G; IN_657] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_657(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 658u64 => { + let __inp: [G; IN_658] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_658(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 659u64 => { + let __inp: [G; IN_659] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_659(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 660u64 => { + let __inp: [G; IN_660] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_660(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 661u64 => { + let __inp: [G; IN_661] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_661(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 662u64 => { + let __inp: [G; IN_662] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_662(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 663u64 => { + let __inp: [G; IN_663] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_663(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 664u64 => { + let __inp: [G; IN_664] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_664(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 665u64 => { + let __inp: [G; IN_665] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_665(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 666u64 => { + let __inp: [G; IN_666] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_666(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 667u64 => { + let __inp: [G; IN_667] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_667(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 668u64 => { + let __inp: [G; IN_668] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_668(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 669u64 => { + let __inp: [G; IN_669] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_669(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 670u64 => { + let __inp: [G; IN_670] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_670(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 671u64 => { + let __inp: [G; IN_671] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_671(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 672u64 => { + let __inp: [G; IN_672] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_672(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 673u64 => { + let __inp: [G; IN_673] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_673(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 674u64 => { + let __inp: [G; IN_674] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_674(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 675u64 => { + let __inp: [G; IN_675] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_675(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 676u64 => { + let __inp: [G; IN_676] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_676(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 677u64 => { + let __inp: [G; IN_677] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_677(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 678u64 => { + let __inp: [G; IN_678] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_678(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 679u64 => { + let __inp: [G; IN_679] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_679(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 680u64 => { + let __inp: [G; IN_680] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_680(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 681u64 => { + let __inp: [G; IN_681] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_681(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 682u64 => { + let __inp: [G; IN_682] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_682(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 683u64 => { + let __inp: [G; IN_683] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_683(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 684u64 => { + let __inp: [G; IN_684] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_684(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 685u64 => { + let __inp: [G; IN_685] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_685(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 686u64 => { + let __inp: [G; IN_686] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_686(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 687u64 => { + let __inp: [G; IN_687] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_687(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 688u64 => { + let __inp: [G; IN_688] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_688(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 689u64 => { + let __inp: [G; IN_689] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_689(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 690u64 => { + let __inp: [G; IN_690] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_690(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 691u64 => { + let __inp: [G; IN_691] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_691(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 692u64 => { + let __inp: [G; IN_692] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_692(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 693u64 => { + let __inp: [G; IN_693] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_693(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 694u64 => { + let __inp: [G; IN_694] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_694(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 695u64 => { + let __inp: [G; IN_695] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_695(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 696u64 => { + let __inp: [G; IN_696] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_696(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 697u64 => { + let __inp: [G; IN_697] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_697(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 698u64 => { + let __inp: [G; IN_698] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_698(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 699u64 => { + let __inp: [G; IN_699] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_699(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 700u64 => { + let __inp: [G; IN_700] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_700(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 701u64 => { + let __inp: [G; IN_701] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_701(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 702u64 => { + let __inp: [G; IN_702] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_702(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 703u64 => { + let __inp: [G; IN_703] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_703(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 704u64 => { + let __inp: [G; IN_704] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_704(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 705u64 => { + let __inp: [G; IN_705] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_705(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 706u64 => { + let __inp: [G; IN_706] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_706(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 707u64 => { + let __inp: [G; IN_707] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_707(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 708u64 => { + let __inp: [G; IN_708] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_708(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 709u64 => { + let __inp: [G; IN_709] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_709(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 710u64 => { + let __inp: [G; IN_710] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_710(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 711u64 => { + let __inp: [G; IN_711] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_711(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 712u64 => { + let __inp: [G; IN_712] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_712(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 713u64 => { + let __inp: [G; IN_713] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_713(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 714u64 => { + let __inp: [G; IN_714] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_714(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 715u64 => { + let __inp: [G; IN_715] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_715(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 716u64 => { + let __inp: [G; IN_716] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_716(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 717u64 => { + let __inp: [G; IN_717] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_717(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 718u64 => { + let __inp: [G; IN_718] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_718(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 719u64 => { + let __inp: [G; IN_719] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_719(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 720u64 => { + let __inp: [G; IN_720] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_720(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 721u64 => { + let __inp: [G; IN_721] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_721(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 722u64 => { + let __inp: [G; IN_722] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_722(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 723u64 => { + let __inp: [G; IN_723] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_723(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 724u64 => { + let __inp: [G; IN_724] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_724(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 725u64 => { + let __inp: [G; IN_725] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_725(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 726u64 => { + let __inp: [G; IN_726] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_726(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 727u64 => { + let __inp: [G; IN_727] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_727(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 728u64 => { + let __inp: [G; IN_728] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_728(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 729u64 => { + let __inp: [G; IN_729] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_729(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 730u64 => { + let __inp: [G; IN_730] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_730(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 731u64 => { + let __inp: [G; IN_731] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_731(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 732u64 => { + let __inp: [G; IN_732] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_732(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 733u64 => { + let __inp: [G; IN_733] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_733(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 734u64 => { + let __inp: [G; IN_734] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_734(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 735u64 => { + let __inp: [G; IN_735] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_735(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 736u64 => { + let __inp: [G; IN_736] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_736(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 737u64 => { + let __inp: [G; IN_737] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_737(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 738u64 => { + let __inp: [G; IN_738] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_738(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 739u64 => { + let __inp: [G; IN_739] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_739(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 740u64 => { + let __inp: [G; IN_740] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_740(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 741u64 => { + let __inp: [G; IN_741] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_741(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + 742u64 => { + let __inp: [G; IN_742] = args.try_into().expect("input size mismatch"); + let __out = aiur_fn_742(__inp, record, io_buffer, false)?; + return Ok(__out.to_vec()); + }, + _ => { + return Err(ExecError::InvalidFunIdx(fun_idx)); + }, + } +} diff --git a/crates/ix/src/aiur_ixvm_runner.rs b/crates/ix/src/aiur_ixvm_runner.rs new file mode 100644 index 00000000..aacc2d17 --- /dev/null +++ b/crates/ix/src/aiur_ixvm_runner.rs @@ -0,0 +1,39 @@ +//! IxVM-native execute path. +//! +//! Parallel to `aiur::execute::Toplevel::execute`, but routes the +//! Aiur fn invocation through the codegen'd Rust kernel +//! (`crate::aiur_ixvm::execute_generated`) instead of the interpreter. +//! +//! Same `QueryRecord` shape, same multiplicity rules, same memory and +//! IO side effects — so the trace produced here is byte-for-byte +//! identical to the interpreter's (modulo the `execute_generated` +//! codegen's correctness, which is the standing parity invariant). +//! +//! Caller still needs a `Toplevel` to size the `QueryRecord` correctly +//! (one `QueryMap` per function, one per `memory_sizes` entry). The +//! `Toplevel`'s bytecode is NOT walked at execution time; only its +//! shape is consulted. + +use aiur::G; +use aiur::bytecode::{FunIdx, Toplevel}; +use aiur::execute::{ExecError, IOBuffer, QueryRecord}; +use crate::aiur_ixvm::execute_generated; + +/// Mirror of `Toplevel::execute` (same return shape, same +/// `entry`-flag gate), but routes execution through the codegen'd +/// Rust kernel. Deep recursion is handled via per-fn +/// `stacker::maybe_grow` checks in the generated code — no +/// pre-reserved giant stack on this thread, no scope dance. +pub fn execute_ixvm( + toplevel: &Toplevel, + fun_idx: FunIdx, + args: Vec, + io_buffer: &mut IOBuffer, +) -> Result<(QueryRecord, Vec), ExecError> { + if !toplevel.functions[fun_idx].entry { + return Err(ExecError::NotEntryFunction(fun_idx)); + } + let mut record = QueryRecord::new(toplevel); + let output = execute_generated(fun_idx, &args, &mut record, io_buffer)?; + Ok((record, output)) +} diff --git a/crates/ix/src/aiur_ixvm_witness.rs b/crates/ix/src/aiur_ixvm_witness.rs new file mode 100644 index 00000000..59d8c04e --- /dev/null +++ b/crates/ix/src/aiur_ixvm_witness.rs @@ -0,0 +1,309 @@ +//! Rust port of `IxVM.ClaimHarness.buildShardCheckEnvWitness`. +//! +//! Replaces the Lean-side IOBuffer construction (~92% of shard +//! wall time on heavy partitions) with a direct Rust implementation +//! that builds `aiur::execute::IOBuffer` without per-byte boxing +//! into Lean values. +//! +//! Mirrors the per-channel layout documented in +//! `Ix/IxVM/ClaimHarness.lean`: +//! +//! | Tier | ch | purpose | key | value | +//! |-------|----|--------------------------|----------------|-----------| +//! | Ctrl | 0 | claim wire bytes | claim_digest | bytes | +//! | Ctrl | 1 | assumption tree bytes | tree.root | bytes | +//! | Const | 2 | constant wire bytes | const addr | bytes | +//! | Const | 3 | Defn reducibility hint | Defn addr | single G | +//! | Blob | 4 | blob discriminator | addr | one byte | +//! | Blob | 5 | blob raw bytes | blob addr | bytes | +//! +//! Soundness model unchanged — every byte-stream is blake3-verified +//! kernel-side against its content-addressed key. +//! +//! # Parallelism +//! +//! Two hot phases use rayon for thread-level parallelism: +//! +//! * **Closure walk** (`closure_from_set`): each owned addr's +//! transitive walk runs on its own thread; results are unioned +//! into a `DashSet` to dedupe across threads. +//! * **Byte→G conversion** (`add_entries`): for each addr in the +//! closure, the per-const `(key, data)` tuple is built in parallel +//! with rayon's `par_bridge`. Only the final IOBuffer assembly +//! (extending channel arenas + inserting into the key→(idx,len) +//! map) runs serially, since the arena `idx` is monotonic. + +use dashmap::DashSet; +use multi_stark::p3_field::PrimeCharacteristicRing; +use rayon::prelude::*; +use rustc_hash::FxHashSet; + +use aiur::G; +use aiur::execute::{IOBuffer, IOKeyInfo}; +use ix_common::address::Address; +use ix_common::env::ReducibilityHints; +use ixon::Env; +use ixon::assumption_tree::AssumptionTree; +use ixon::constant::ConstantInfo; +use ixon::proof::Claim; + +/// Append `data` to the per-channel arena and record `(idx, len)` +/// in the `(channel, key)` info map. +#[inline] +fn extend(io: &mut IOBuffer, channel: G, key: Vec, data: Vec) { + let arena = io.data.entry(channel).or_default(); + let idx = arena.len(); + let len = data.len(); + arena.extend(data); + io.map.insert((channel, key), IOKeyInfo { idx, len }); +} + +#[inline] +fn addr_key(addr: &Address) -> Vec { + addr.as_bytes().iter().map(|b| G::from_u8(*b)).collect() +} + +#[inline] +fn bytes_to_g(bytes: &[u8]) -> Vec { + bytes.iter().map(|b| G::from_u8(*b)).collect() +} + +/// Mirror of `IxVM.ClaimHarness.hintToG`: +/// `Opaque → 0`, `Abbrev → 0xFFFFFFFF`, `Regular n → min(1+n, 0xFFFFFFFE)`. +fn hint_to_g(h: &ReducibilityHints) -> G { + let v: u64 = match h { + ReducibilityHints::Opaque => 0, + ReducibilityHints::Abbrev => 0xFFFF_FFFF, + ReducibilityHints::Regular(n) => { + let v = (1u64).saturating_add(u64::from(*n)); + v.min(0xFFFF_FFFE) + }, + }; + G::from_u64(v) +} + +/// Single-source transitive closure over `Constant.refs` + projection +/// blocks. Sequential BFS. +fn closure_from(env: &Env, target: &Address, visited: &DashSet
) { + let mut stack: Vec
= vec![target.clone()]; + while let Some(addr) = stack.pop() { + if !visited.insert(addr.clone()) { + continue; + } + let Some(c) = env.get_const(&addr) else { + continue; + }; + for r in &c.refs { + if !visited.contains(r) { + stack.push(r.clone()); + } + } + let block = match &c.info { + ConstantInfo::IPrj(p) => Some(&p.block), + ConstantInfo::CPrj(p) => Some(&p.block), + ConstantInfo::RPrj(p) => Some(&p.block), + ConstantInfo::DPrj(p) => Some(&p.block), + _ => None, + }; + if let Some(b) = block { + if !visited.contains(b) { + stack.push(b.clone()); + } + } + } +} + +/// Parallel transitive closure: each owned addr's walk runs on its +/// own thread, results unioned via the shared `DashSet`. +fn closure_from_set(env: &Env, owned: &[Address]) -> FxHashSet
{ + let visited: DashSet
= DashSet::new(); + owned.par_iter().for_each(|a| closure_from(env, a, &visited)); + visited.into_iter().collect() +} + +/// Per-channel entry produced by the parallel scan over the closure. +/// Sorted into the IOBuffer in a serial fold afterwards. +struct ChannelEntries { + /// ch 2 const entries: `(key, bytes-as-G)`. + consts: Vec<(Vec, Vec)>, + /// ch 5 blob entries: `(key, bytes-as-G)`. + blobs: Vec<(Vec, Vec)>, + /// ch 4 discriminator: `(key, [g])` — `g` is `1` for const, `0` for blob. + discs: Vec<(Vec, G)>, + /// ch 3 Defn hint: `(key, hint-G)`. + hints: Vec<(Vec, G)>, +} + +impl ChannelEntries { + fn new() -> Self { + Self { + consts: Vec::new(), + blobs: Vec::new(), + discs: Vec::new(), + hints: Vec::new(), + } + } +} + +/// Build the per-channel `(key, data)` tuples for every addr in +/// `closure`. Byte→G conversion runs in parallel; the IOBuffer +/// assembly is sequential because arena `idx` must be monotonic. +fn add_entries_parallel( + env: &Env, + closure: &FxHashSet
, + io: &mut IOBuffer, +) { + let ch_const = G::from_u8(2); + let ch_hint = G::from_u8(3); + let ch_disc = G::from_u8(4); + let ch_blob = G::from_u8(5); + let g_zero = G::ZERO; + let g_one = G::ONE; + + // Pull the set of addrs we'll touch as a Vec for parallel iteration. + let closure_vec: Vec
= closure.iter().cloned().collect(); + + // Phase A: parallel byte conversion per closure addr. Each thread + // produces its own partial `ChannelEntries`. + let partials: Vec = closure_vec + .par_chunks(256) + .map(|chunk| { + let mut p = ChannelEntries::new(); + for addr in chunk { + let key = addr_key(addr); + // Const lookup first. + if let Some(lc) = env.consts.get(addr) { + let data = bytes_to_g(lc.raw_bytes()); + p.consts.push((key.clone(), data)); + p.discs.push((key, g_one)); + continue; + } + // Blob lookup. + if let Some(blob) = env.blobs.get(addr) { + let data = bytes_to_g(blob.value()); + p.blobs.push((key.clone(), data)); + p.discs.push((key, g_zero)); + continue; + } + // Neither — closure includes some addresses (e.g. blob refs + // from const.refs) that may not be in env.blobs if the env + // doesn't carry them; skip silently to mirror the Lean side. + } + // Hints come from env.anon_hints (sidecar). Collect per chunk. + for addr in chunk { + if let Some(h) = env.anon_hints.get(addr) { + p.hints.push((addr_key(addr), hint_to_g(h))); + } + } + p + }) + .collect(); + + // Phase B: serial assembly into the IOBuffer. + for p in partials { + for (key, data) in p.consts { + extend(io, ch_const, key, data); + } + for (key, data) in p.blobs { + extend(io, ch_blob, key, data); + } + for (key, disc) in p.discs { + extend(io, ch_disc, key, vec![disc]); + } + for (key, hint) in p.hints { + extend(io, ch_hint, key, vec![hint]); + } + } +} + +/// Build a `Check { const_addr, assumptions=None }` claim witness +/// directly in Rust. Returns `(claim, claim_digest_input, io_buffer)` +/// ready to feed to `crate::ix::aiur_ixvm_runner::execute_ixvm`. +/// +/// Mirrors `IxVM.ClaimHarness.buildClaimWitness` on the +/// `Claim.check addr none` branch: closure-from-addr seeds ch 2/3/4/5, +/// claim bytes go to ch 0. Asm-tree variant deferred — caller falls +/// back to Lean witness when `asm = Some _`. +pub fn build_claim_check_witness( + env: &Env, + target: &Address, +) -> Result<(Claim, Vec, IOBuffer), String> { + // Transitive closure rooted at `target`. + let closure: FxHashSet
= closure_from_set(env, &[target.clone()]); + + let claim = Claim::Check { + const_addr: target.clone(), + assumptions: None, + }; + let mut claim_bytes: Vec = Vec::new(); + claim.put(&mut claim_bytes); + let digest = Address::hash(&claim_bytes); + let digest_key = addr_key(&digest); + + let mut io = IOBuffer { + data: rustc_hash::FxHashMap::default(), + map: rustc_hash::FxHashMap::default(), + }; + // ch 0: claim bytes + extend(&mut io, G::ZERO, digest_key.clone(), bytes_to_g(&claim_bytes)); + // ch 2/3/4/5: per-const/blob/hint entries — parallel byte conversion. + add_entries_parallel(env, &closure, &mut io); + + Ok((claim, digest_key, io)) +} + +/// Build a `CheckEnv`-shaped shard witness directly in Rust. Returns +/// `(claim, claim_digest_input, io_buffer)` ready to feed to +/// `crate::ix::aiur_ixvm_runner::execute_ixvm`. +pub fn build_shard_check_env_witness( + env: &Env, + owned: &[Address], +) -> Result<(Claim, Vec, IOBuffer), String> { + let owned_set: FxHashSet
= owned.iter().cloned().collect(); + + // Transitive closure over `Constant.refs` + projection blocks, parallel + // per owned addr. + let closure = closure_from_set(env, owned); + + let mut closure_vec: Vec
= closure.iter().cloned().collect(); + closure_vec.sort(); + let frontier: Vec
= closure_vec + .iter() + .filter(|a| !owned_set.contains(*a)) + .cloned() + .collect(); + let env_tree = AssumptionTree::canonical(&closure_vec) + .ok_or_else(|| "build_shard_check_env_witness: empty closure".to_string())?; + let asm_tree = AssumptionTree::canonical(&frontier); + + let claim = Claim::CheckEnv { + root: env_tree.root(), + assumptions: asm_tree.as_ref().map(|t| t.root()), + }; + let mut claim_bytes: Vec = Vec::new(); + claim.put(&mut claim_bytes); + let digest = Address::hash(&claim_bytes); + let digest_key = addr_key(&digest); + + let mut io = IOBuffer { + data: rustc_hash::FxHashMap::default(), + map: rustc_hash::FxHashMap::default(), + }; + // ch 0: claim bytes + extend(&mut io, G::ZERO, digest_key.clone(), bytes_to_g(&claim_bytes)); + // ch 2/3/4/5 per-const/blob/hint entries — parallel byte conversion. + add_entries_parallel(env, &closure, &mut io); + // ch 1: env tree + extend( + &mut io, + G::ONE, + addr_key(&env_tree.root()), + bytes_to_g(&env_tree.ser()), + ); + // ch 1: asm tree (if present) + if let Some(at) = asm_tree { + extend(&mut io, G::ONE, addr_key(&at.root()), bytes_to_g(&at.ser())); + } + + Ok((claim, digest_key, io)) +} diff --git a/crates/ix/src/env_handle.rs b/crates/ix/src/env_handle.rs new file mode 100644 index 00000000..551de795 --- /dev/null +++ b/crates/ix/src/env_handle.rs @@ -0,0 +1,59 @@ +//! `EnvHandle`: a Rust-owned `ixon::Env` exposed to Lean as an opaque +//! external handle. +//! +//! Built once per CLI invocation from either a memory-mappable `.ixe` +//! path or a `Ixon.serEnv`-shaped byte blob. All downstream per-claim / +//! per-shard FFI calls take a `&EnvHandle` (shared across the batch) so +//! the env is parsed exactly once instead of every call. +//! +//! `anon_hints` (`Defn` reducibility hints) are populated at handle +//! construction time. `Env::get_anon_mmap` already harvests them; +//! `Env::get` (full-form decode used by the bytes-blob path) does +//! not, so `from_bytes` runs the harvest post-decode. + +use ixon::{ + Env, + metadata::ConstantMetaInfo, +}; + +pub struct EnvHandle { + pub env: Env, +} + +impl EnvHandle { + /// Load via `Env::get_anon_mmap` (zero-copy mmap of the `.ixe` file). + /// Anon-mode parser already harvests `anon_hints` — no post-pass. + pub fn from_ixe_path(path: &std::path::Path) -> Result { + let env = Env::get_anon_mmap(path)?; + Ok(Self { env }) + } + + /// Decode a serialized env blob (`Ixon.serEnv` output) via + /// `Env::get`, then harvest `anon_hints` from each `Def` named + /// entry. Used by the compiled-Lean-env path where the env is built + /// in Lean memory and serialized for the cross-FFI handoff. + pub fn from_bytes(bytes: &[u8]) -> Result { + let mut cursor: &[u8] = bytes; + let mut env = Env::get(&mut cursor)?; + // `Env::get` reads named entries but doesn't populate + // `env.anon_hints`. Walk `env.named` and insert each `Def` + // variant's `hints`. Mirrors the in-line harvest inside + // `Env::get_anon`. + let hints: Vec<_> = env + .named + .iter() + .filter_map(|entry| { + let named = entry.value(); + if let ConstantMetaInfo::Def { hints, .. } = &named.meta.info { + Some((named.addr.clone(), hints.clone())) + } else { + None + } + }) + .collect(); + for (addr, h) in hints { + env.anon_hints.insert(addr, h); + } + Ok(Self { env }) + } +} diff --git a/crates/ix/src/lib.rs b/crates/ix/src/lib.rs new file mode 100644 index 00000000..fb1b2aaa --- /dev/null +++ b/crates/ix/src/lib.rs @@ -0,0 +1,8 @@ +//! IxVM-specific Rust glue: codegen'd kernel, native runner, witness +//! builder. Bridges the `aiur` proving framework with `ixon` / +//! `ix-common` content-addressed env types. + +pub mod aiur_ixvm; +pub mod aiur_ixvm_runner; +pub mod aiur_ixvm_witness; +pub mod env_handle;